@rk0429/agentic-relay 1.3.1 → 1.4.1

package/dist/relay.mjs

@@ -1027,7 +1027,7 @@ function buildContextFromEnv() {
   const depth = Number(process.env["RELAY_DEPTH"] ?? "0");
   return { traceId, parentSessionId, depth };
 }
-async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2, backendSelector, childHttpUrl, onProgress, agentEventStore, hookMemoryDir = "./memory") {
+async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2, backendSelector, childHttpUrl, onProgress, agentEventStore, hookMemoryDir = "./memory", taskCompleter) {
   onProgress?.({ stage: "initializing", percent: 0 });
   let effectiveBackend;
   let selectionReason;
@@ -1378,6 +1378,20 @@ ${input.prompt}`;
           tokenUsage: result.tokenUsage
         }
       });
+      if (taskCompleter && session.metadata.taskId) {
+        try {
+          await taskCompleter.completeTask(
+            session.metadata.taskId,
+            session.metadata.agentType ?? session.relaySessionId,
+            `Auto-completed by spawn_agent. Session: ${session.relaySessionId}`
+          );
+          logger.info(`Auto-completed task ${session.metadata.taskId} via taskCompleter`);
+        } catch (taskError) {
+          logger.warn(
+            `Failed to auto-complete task ${session.metadata.taskId}: ${taskError instanceof Error ? taskError.message : String(taskError)}`
+          );
+        }
+      }
       if (hooksEngine2) {
         try {
           await hooksEngine2.emit("on-session-complete", {
@@ -1717,7 +1731,7 @@ var init_conflict_detector = __esm({
 });
 
 // src/mcp-server/tools/spawn-agents-parallel.ts
-async function executeSpawnAgentsParallel(agents, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2, backendSelector, childHttpUrl, onProgress, agentEventStore, hookMemoryDir = "./memory") {
+async function executeSpawnAgentsParallel(agents, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2, backendSelector, childHttpUrl, onProgress, agentEventStore, hookMemoryDir = "./memory", taskCompleter) {
   for (let index = 0; index < agents.length; index += 1) {
     try {
       resolveValidatedSessionMetadata(agents[index]);
@@ -1800,7 +1814,8 @@ async function executeSpawnAgentsParallel(agents, registry2, sessionManager2, gu
         childHttpUrl,
         void 0,
         agentEventStore,
-        hookMemoryDir
+        hookMemoryDir,
+        taskCompleter
       ).then((result) => {
         completedCount++;
         onProgress?.({
@@ -2324,7 +2339,7 @@ var init_server = __esm({
     };
     MAX_CHILD_HTTP_SESSIONS = 100;
     RelayMCPServer = class {
-      constructor(registry2, sessionManager2, guardConfig, hooksEngine2, contextMonitor2, inlineSummaryLength, responseOutputDir, relayConfig) {
+      constructor(registry2, sessionManager2, guardConfig, hooksEngine2, contextMonitor2, inlineSummaryLength, responseOutputDir, relayConfig, taskCompleter) {
         this.registry = registry2;
         this.sessionManager = sessionManager2;
         this.hooksEngine = hooksEngine2;
@@ -2332,6 +2347,7 @@ var init_server = __esm({
         this.inlineSummaryLength = inlineSummaryLength;
         this.responseOutputDir = responseOutputDir;
         this.relayConfig = relayConfig;
+        this.taskCompleter = taskCompleter;
         this.guard = new RecursionGuard(guardConfig);
         this.backendSelector = new BackendSelector();
         this.staleThresholdSec = relayConfig?.sessionHealth?.staleThresholdSec ?? 300;
@@ -2362,7 +2378,7 @@ var init_server = __esm({
           this.agentEventStore
         );
         this.server = new McpServer(
-          { name: "agentic-relay", version: "1.3.1" },
+          { name: "agentic-relay", version: "1.4.1" },
           createMcpServerOptions()
         );
         this.registerTools(this.server);
@@ -2403,7 +2419,8 @@ var init_server = __esm({
               this._childHttpUrl,
               void 0,
               this.agentEventStore,
-              this.hookMemoryDir
+              this.hookMemoryDir,
+              this.taskCompleter
             );
             const controlOptions = {
               inlineSummaryLength: this.inlineSummaryLength ?? DEFAULT_INLINE_SUMMARY_LENGTH,
@@ -2458,7 +2475,8 @@ var init_server = __esm({
               this._childHttpUrl,
               void 0,
               this.agentEventStore,
-              this.hookMemoryDir
+              this.hookMemoryDir,
+              this.taskCompleter
             );
             const controlOptions = {
               inlineSummaryLength: this.inlineSummaryLength ?? DEFAULT_INLINE_SUMMARY_LENGTH,
@@ -2579,7 +2597,8 @@ var init_server = __esm({
                 this._childHttpUrl,
                 void 0,
                 this.agentEventStore,
-                this.hookMemoryDir
+                this.hookMemoryDir,
+                this.taskCompleter
               );
               const controlOptions = {
                 inlineSummaryLength: this.inlineSummaryLength ?? DEFAULT_INLINE_SUMMARY_LENGTH,
@@ -2830,7 +2849,7 @@ var init_server = __esm({
             sessionIdGenerator: () => randomUUID()
           });
           const server = new McpServer(
-            { name: "agentic-relay", version: "1.3.1" },
+            { name: "agentic-relay", version: "1.4.1" },
             createMcpServerOptions()
           );
           this.registerTools(server);
@@ -2895,8 +2914,1249 @@ var init_server = __esm({
   }
 });
 
+// src/tui/services/conversation-engine.ts
+import { nanoid as nanoid4 } from "nanoid";
+var ConversationEngine;
+var init_conversation_engine = __esm({
+  "src/tui/services/conversation-engine.ts"() {
+    "use strict";
+    ConversationEngine = class {
+      constructor(registry2, sessionManager2, hooksEngine2, contextMonitor2) {
+        this.registry = registry2;
+        this.sessionManager = sessionManager2;
+        this.hooksEngine = hooksEngine2;
+        this.contextMonitor = contextMonitor2;
+      }
+      messages = [];
+      sessionId = null;
+      totalTokens = { input: 0, output: 0 };
+      /** セッション初期化。session-init hook を発火 */
+      async initSession(backendId) {
+        const session = await this.sessionManager.create({ backendId });
+        this.sessionId = session.relaySessionId;
+        await this.hooksEngine.emit("session-init", {
+          event: "session-init",
+          sessionId: session.relaySessionId,
+          backendId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {}
+        });
+        return session.relaySessionId;
+      }
+      /** ユーザー入力を処理し、ConversationEvent を生成する AsyncGenerator */
+      async *processInput(text, backendId) {
+        const { results: prePromptResults } = await this.hooksEngine.emitAndCollectMetadata("pre-prompt", {
+          event: "pre-prompt",
+          sessionId: this.sessionId ?? "",
+          backendId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { prompt: text }
+        });
+        const rejected = prePromptResults.find((r) => !r.output.allow);
+        if (rejected) {
+          yield {
+            type: "error",
+            message: rejected.output.message || "Request rejected by pre-prompt hook"
+          };
+          return;
+        }
+        this.messages.push({
+          id: nanoid4(),
+          role: "user",
+          content: text,
+          timestamp: /* @__PURE__ */ new Date(),
+          backendId
+        });
+        const adapter = this.registry.get(backendId);
+        const flags = {
+          prompt: text,
+          outputFormat: "stream-json"
+        };
+        if (this.sessionId) {
+          const session = await this.sessionManager.get(this.sessionId);
+          if (session?.nativeSessionId) {
+            flags.resume = session.nativeSessionId;
+          }
+        }
+        let assistantContent = "";
+        if (adapter.executeStreaming) {
+          for await (const event of adapter.executeStreaming(flags)) {
+            yield this.convertStreamEvent(event);
+            if (event.type === "text") {
+              assistantContent += event.text;
+            }
+            if (event.type === "done") {
+              await this.handleDoneEvent(event, backendId);
+            }
+          }
+        } else {
+          const result = await adapter.execute(flags);
+          assistantContent = result.stdout;
+          yield { type: "text", text: result.stdout };
+          if (result.nativeSessionId && this.sessionId) {
+            await this.sessionManager.update(this.sessionId, {
+              nativeSessionId: result.nativeSessionId
+            });
+          }
+          if (result.tokenUsage) {
+            this.totalTokens.input += result.tokenUsage.inputTokens;
+            this.totalTokens.output += result.tokenUsage.outputTokens;
+            this.contextMonitor.updateUsage(
+              this.sessionId ?? "",
+              backendId,
+              this.totalTokens.input + this.totalTokens.output
+            );
+          }
+          yield { type: "done", result };
+        }
+        this.messages.push({
+          id: nanoid4(),
+          role: "assistant",
+          content: assistantContent,
+          timestamp: /* @__PURE__ */ new Date(),
+          backendId
+        });
+        await this.hooksEngine.emit("post-response", {
+          event: "post-response",
+          sessionId: this.sessionId ?? "",
+          backendId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { response: assistantContent }
+        });
+      }
+      /** StreamEvent → ConversationEvent の変換ヘルパー */
+      convertStreamEvent(event) {
+        if (event.type === "done") {
+          return { type: "done", result: event.result };
+        }
+        return event;
+      }
+      /** done イベントのハンドリング: セッション更新 + トークン累積 + ContextMonitor 更新 */
+      async handleDoneEvent(event, backendId) {
+        if (event.nativeSessionId && this.sessionId) {
+          await this.sessionManager.update(this.sessionId, {
+            nativeSessionId: event.nativeSessionId
+          });
+        }
+        if (event.result.tokenUsage) {
+          this.totalTokens.input += event.result.tokenUsage.inputTokens;
+          this.totalTokens.output += event.result.tokenUsage.outputTokens;
+          this.contextMonitor.updateUsage(
+            this.sessionId ?? "",
+            backendId,
+            this.totalTokens.input + this.totalTokens.output
+          );
+        }
+      }
+      getMessages() {
+        return [...this.messages];
+      }
+      getSessionId() {
+        return this.sessionId;
+      }
+      getTotalTokens() {
+        return { ...this.totalTokens };
+      }
+      /** バックエンドを切り替え、新セッションを初期化 */
+      async switchBackend(newBackendId, contextSummary, _resumeSessionId) {
+        if (this.sessionId) {
+          await this.sessionManager.update(this.sessionId, {
+            status: "completed"
+          });
+        }
+        const session = await this.sessionManager.create({
+          backendId: newBackendId
+        });
+        this.sessionId = session.relaySessionId;
+        await this.hooksEngine.emit("session-init", {
+          event: "session-init",
+          sessionId: session.relaySessionId,
+          backendId: newBackendId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { contextSummary }
+        });
+        if (contextSummary) {
+          this.messages.push({
+            id: nanoid4(),
+            role: "system",
+            content: contextSummary,
+            timestamp: /* @__PURE__ */ new Date(),
+            backendId: newBackendId
+          });
+        }
+        this.totalTokens = { input: 0, output: 0 };
+        return session.relaySessionId;
+      }
+      clearMessages() {
+        this.messages = [];
+      }
+    };
+  }
+});
+
+// src/tui/services/backend-orchestrator.ts
+var BackendOrchestrator;
+var init_backend_orchestrator = __esm({
+  "src/tui/services/backend-orchestrator.ts"() {
+    "use strict";
+    BackendOrchestrator = class {
+      constructor(registry2, sessionManager2, hooksEngine2, strategy = "shared-history") {
+        this.registry = registry2;
+        this.sessionManager = sessionManager2;
+        this.hooksEngine = hooksEngine2;
+        this.strategy = strategy;
+      }
+      backends = /* @__PURE__ */ new Map();
+      activeBackendId = null;
+      /** 各バックエンドの relay sessionId を保持（suspend/resume 用） */
+      sessionIds = /* @__PURE__ */ new Map();
+      /** バックエンドを検出し初期化。優先順位: claude > codex > gemini */
+      async initialize(preferredBackend) {
+        const priorities = ["claude", "codex", "gemini"];
+        for (const id of priorities) {
+          if (!this.registry.has(id)) continue;
+          const adapter = this.registry.get(id);
+          const health = await adapter.checkHealth();
+          this.backends.set(id, {
+            id,
+            status: health.healthy ? "available" : "unavailable",
+            health,
+            nativeSessionId: null
+          });
+        }
+        if (preferredBackend && this.backends.get(preferredBackend)?.status === "available") {
+          this.activeBackendId = preferredBackend;
+          this.backends.get(preferredBackend).status = "active";
+          return preferredBackend;
+        }
+        const defaultBackend = priorities.find(
+          (id) => this.backends.get(id)?.status === "available"
+        );
+        if (!defaultBackend) {
+          throw new Error("No available backends found");
+        }
+        this.activeBackendId = defaultBackend;
+        this.backends.get(defaultBackend).status = "active";
+        return defaultBackend;
+      }
+      /** バックエンド切り替え（切替戦略・hook 発火・resume 対応） */
+      async switchTo(target, messages) {
+        const state = this.backends.get(target);
+        if (!state || state.status === "unavailable") {
+          throw new Error(`Backend ${target} is not available`);
+        }
+        const from = this.activeBackendId;
+        if (from) {
+          await this.hooksEngine.emit("pre-prompt", {
+            event: "pre-prompt",
+            sessionId: this.sessionIds.get(from) ?? "",
+            backendId: from,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data: { type: "backend-switch", from, to: target }
+          });
+          const prev = this.backends.get(from);
+          if (prev) prev.status = "available";
+        }
+        this.activeBackendId = target;
+        state.status = "active";
+        const result = {};
+        if (this.strategy === "shared-history" && messages && messages.length > 0) {
+          result.contextSummary = this.generateContextSummary(messages);
+        }
+        const existingSessionId = this.sessionIds.get(target);
+        if (existingSessionId) {
+          result.resumeSessionId = existingSessionId;
+        }
+        return result;
+      }
+      /** メッセージ履歴からコンテキスト要約を生成 */
+      generateContextSummary(messages) {
+        const maxChars = 2e3;
+        const relevant = messages.slice(-20);
+        const lines = [];
+        lines.push("=== Previous conversation context ===");
+        for (const msg of relevant) {
+          const prefix = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "System";
+          const truncated = msg.content.length > 200 ? msg.content.slice(0, 200) + "..." : msg.content;
+          lines.push(`${prefix}: ${truncated}`);
+        }
+        lines.push("=== End of context ===");
+        const summary = lines.join("\n");
+        return summary.length > maxChars ? summary.slice(0, maxChars) + "\n..." : summary;
+      }
+      /** セッション ID を登録 */
+      setSessionId(backendId, sessionId) {
+        this.sessionIds.set(backendId, sessionId);
+      }
+      /** セッション ID を取得 */
+      getSessionId(backendId) {
+        return this.sessionIds.get(backendId);
+      }
+      /** 現在の切替戦略を取得 */
+      getStrategy() {
+        return this.strategy;
+      }
+      /** 切替戦略を変更 */
+      setStrategy(strategy) {
+        this.strategy = strategy;
+      }
+      getActiveId() {
+        return this.activeBackendId;
+      }
+      getActiveAdapter() {
+        if (!this.activeBackendId) {
+          throw new Error("No active backend");
+        }
+        return this.registry.get(this.activeBackendId);
+      }
+      getStatuses() {
+        return [...this.backends.values()];
+      }
+      isAvailable(id) {
+        const state = this.backends.get(id);
+        return state?.status === "available" || state?.status === "active";
+      }
+    };
+  }
+});
+
+// src/tui/components/StatusBar.tsx
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import { jsx, jsxs } from "react/jsx-runtime";
+function StatusBar({ backendId, model, sessionId, tokenCount, isStreaming, showTokenCount }) {
+  const totalTokens = tokenCount.input + tokenCount.output;
+  const tokenStr = totalTokens > 1e3 ? `${(totalTokens / 1e3).toFixed(1)}k` : `${totalTokens}`;
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderBottom: true, paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsx(Text, { bold: true, color: BACKEND_COLORS[backendId], children: backendId }) }),
+    model && /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: model }) }),
+    showTokenCount !== false && /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      tokenStr,
+      " tokens"
+    ] }) }),
+    sessionId && /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "session: ",
+      sessionId.slice(0, 8)
+    ] }) }),
+    isStreaming && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " streaming" })
+    ] })
+  ] });
+}
+var BACKEND_COLORS;
+var init_StatusBar = __esm({
+  "src/tui/components/StatusBar.tsx"() {
+    "use strict";
+    BACKEND_COLORS = {
+      claude: "#D97706",
+      // amber
+      codex: "#059669",
+      // emerald
+      gemini: "#2563EB"
+      // blue
+    };
+  }
+});
+
+// src/tui/services/markdown-renderer.ts
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+var MarkdownRenderer;
+var init_markdown_renderer = __esm({
+  "src/tui/services/markdown-renderer.ts"() {
+    "use strict";
+    MarkdownRenderer = class {
+      constructor() {
+        marked.use(markedTerminal());
+      }
+      render(markdown) {
+        return marked.parse(markdown);
+      }
+    };
+  }
+});
+
+// src/tui/components/MarkdownBlock.tsx
+import { Text as Text2 } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function MarkdownBlock({ content }) {
+  const rendered = renderer.render(content);
+  return /* @__PURE__ */ jsx2(Text2, { children: rendered });
+}
+var renderer;
+var init_MarkdownBlock = __esm({
+  "src/tui/components/MarkdownBlock.tsx"() {
+    "use strict";
+    init_markdown_renderer();
+    renderer = new MarkdownRenderer();
+  }
+});
+
+// src/tui/components/ChatView.tsx
+import { Box as Box2, Text as Text3, Static } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function ChatView({ messages, streamingText, isStreaming }) {
+  const completedMessages = isStreaming ? messages.slice(0, -1) : messages;
+  const lastMessage = isStreaming ? null : messages[messages.length - 1];
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx3(Static, { items: completedMessages, children: (msg) => /* @__PURE__ */ jsx3(MessageLine, { message: msg }, msg.id) }),
+    lastMessage && /* @__PURE__ */ jsx3(MessageLine, { message: lastMessage }),
+    isStreaming && streamingText && /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(MarkdownBlock, { content: streamingText }) })
+  ] });
+}
+function MessageLine({ message }) {
+  if (message.role === "user") {
+    return /* @__PURE__ */ jsxs2(Box2, { marginY: 0, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: ">>> " }),
+      /* @__PURE__ */ jsx3(Text3, { children: message.content })
+    ] });
+  }
+  if (message.role === "system") {
+    return /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: message.content }) });
+  }
+  return /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(MarkdownBlock, { content: message.content }) });
+}
+var init_ChatView = __esm({
+  "src/tui/components/ChatView.tsx"() {
+    "use strict";
+    init_MarkdownBlock();
+  }
+});
+
+// src/tui/components/InputArea.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import TextInput from "ink-text-input";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function InputArea({ value, onChange, onSubmit, isDisabled, placeholder }) {
+  return /* @__PURE__ */ jsxs3(Box3, { borderStyle: "single", borderTop: true, paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: "green", children: "> " }),
+    isDisabled ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "waiting for response..." }) : /* @__PURE__ */ jsx4(
+      TextInput,
+      {
+        value,
+        onChange,
+        onSubmit,
+        placeholder: placeholder ?? "Type a message..."
+      }
+    )
+  ] });
+}
+var init_InputArea = __esm({
+  "src/tui/components/InputArea.tsx"() {
+    "use strict";
+  }
+});
+
+// src/tui/components/ToolProgress.tsx
+import { Box as Box4, Text as Text5 } from "ink";
+import Spinner2 from "ink-spinner";
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function ToolProgress({ tools }) {
+  if (tools.length === 0) return /* @__PURE__ */ jsx5(Fragment, {});
+  return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", marginLeft: 2, children: tools.map((tool) => /* @__PURE__ */ jsxs4(Box4, { children: [
+    tool.status === "running" && /* @__PURE__ */ jsxs4(Text5, { color: "yellow", children: [
+      /* @__PURE__ */ jsx5(Spinner2, { type: "dots" }),
+      " "
+    ] }),
+    tool.status === "completed" && /* @__PURE__ */ jsx5(Text5, { color: "green", children: "[ok] " }),
+    tool.status === "failed" && /* @__PURE__ */ jsx5(Text5, { color: "red", children: "[err] " }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: tool.tool })
+  ] }, tool.id)) });
+}
+var init_ToolProgress = __esm({
+  "src/tui/components/ToolProgress.tsx"() {
+    "use strict";
+  }
+});
+
+// src/tui/components/BackendIndicator.tsx
+import { Box as Box5, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function BackendIndicator({ statuses, activeBackendId }) {
+  const order = ["claude", "codex", "gemini"];
+  return /* @__PURE__ */ jsx6(Box5, { paddingX: 1, gap: 2, children: order.map((id) => {
+    const state = statuses.find((s) => s.id === id);
+    if (!state) return null;
+    const label = BACKEND_LABELS[id];
+    const isActive = id === activeBackendId;
+    const isUnavailable = state.status === "unavailable";
+    return /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
+        label.key,
+        " "
+      ] }),
+      isUnavailable ? /* @__PURE__ */ jsx6(Text6, { strikethrough: true, dimColor: true, children: label.name }) : isActive ? /* @__PURE__ */ jsx6(Text6, { bold: true, color: BACKEND_COLORS2[id], children: label.name }) : /* @__PURE__ */ jsx6(Text6, { color: BACKEND_COLORS2[id], children: label.name })
+    ] }, id);
+  }) });
+}
+var BACKEND_LABELS, BACKEND_COLORS2;
+var init_BackendIndicator = __esm({
+  "src/tui/components/BackendIndicator.tsx"() {
+    "use strict";
+    BACKEND_LABELS = {
+      claude: { key: "^1", name: "Claude" },
+      codex: { key: "^2", name: "Codex" },
+      gemini: { key: "^3", name: "Gemini" }
+    };
+    BACKEND_COLORS2 = {
+      claude: "#D97706",
+      codex: "#059669",
+      gemini: "#2563EB"
+    };
+  }
+});
+
+// src/tui/services/task-poller.ts
+var TaskPoller;
+var init_task_poller = __esm({
+  "src/tui/services/task-poller.ts"() {
+    "use strict";
+    TaskPoller = class {
+      constructor(eventStore, parentSessionId) {
+        this.eventStore = eventStore;
+        this.parentSessionId = parentSessionId;
+      }
+      tasks = /* @__PURE__ */ new Map();
+      lastEventId = null;
+      pollTimer = null;
+      onUpdate = null;
+      /** コールバック登録 */
+      setOnUpdate(callback) {
+        this.onUpdate = callback;
+      }
+      /** ポーリング開始 */
+      startPolling(intervalMs = 2e3) {
+        if (this.pollTimer) return;
+        void this.poll();
+        this.pollTimer = setInterval(() => void this.poll(), intervalMs);
+      }
+      /** ポーリング停止 */
+      stopPolling() {
+        if (this.pollTimer) {
+          clearInterval(this.pollTimer);
+          this.pollTimer = null;
+        }
+      }
+      /** 1回のポーリングサイクル */
+      async poll() {
+        const queryParams = {
+          limit: 100,
+          ...this.lastEventId ? { afterEventId: this.lastEventId } : {},
+          ...this.parentSessionId ? { parentSessionId: this.parentSessionId, recursive: true } : {}
+        };
+        let events;
+        try {
+          ({ events } = this.eventStore.query(queryParams));
+        } catch {
+          this.lastEventId = null;
+          const retryParams = {
+            limit: 100,
+            ...this.parentSessionId ? { parentSessionId: this.parentSessionId, recursive: true } : {}
+          };
+          ({ events } = this.eventStore.query(retryParams));
+        }
+        if (events.length === 0) return;
+        this.lastEventId = events[events.length - 1].eventId;
+        let updated = false;
+        for (const event of events) {
+          updated = this.processEvent(event) || updated;
+        }
+        if (updated && this.onUpdate) {
+          this.onUpdate(this.getTasks());
+        }
+      }
+      /** AgentEvent → TUITask への変換・更新 */
+      processEvent(event) {
+        const taskId = event.data.taskId ?? event.sessionId;
+        const existing = this.tasks.get(taskId);
+        switch (event.type) {
+          case "session-start": {
+            if (!existing) {
+              const description = this.extractDescription(event);
+              this.tasks.set(taskId, {
+                taskId,
+                sessionId: event.sessionId,
+                backendId: event.backendId,
+                description,
+                status: "running",
+                createdAt: new Date(event.timestamp)
+              });
+              return true;
+            }
+            return false;
+          }
+          case "session-complete": {
+            if (existing) {
+              existing.status = "completed";
+              existing.completedAt = new Date(event.timestamp);
+              return true;
+            }
+            this.tasks.set(taskId, {
+              taskId,
+              sessionId: event.sessionId,
+              backendId: event.backendId,
+              description: this.extractDescription(event),
+              status: "completed",
+              createdAt: new Date(event.timestamp),
+              completedAt: new Date(event.timestamp)
+            });
+            return true;
+          }
+          case "session-error": {
+            if (existing) {
+              existing.status = "failed";
+              existing.completedAt = new Date(event.timestamp);
+              existing.error = event.data.error ?? "Unknown error";
+              return true;
+            }
+            this.tasks.set(taskId, {
+              taskId,
+              sessionId: event.sessionId,
+              backendId: event.backendId,
+              description: this.extractDescription(event),
+              status: "failed",
+              createdAt: new Date(event.timestamp),
+              completedAt: new Date(event.timestamp),
+              error: event.data.error ?? "Unknown error"
+            });
+            return true;
+          }
+          case "session-stale": {
+            if (existing && existing.status === "running") {
+              existing.status = "stale";
+              return true;
+            }
+            return false;
+          }
+          case "context-threshold": {
+            return false;
+          }
+          default:
+            return false;
+        }
+      }
+      /** イベントメタデータから説明を抽出 */
+      extractDescription(event) {
+        const label = event.metadata?.label;
+        if (label) return label;
+        const agentType = event.metadata?.agentType;
+        if (agentType) return agentType;
+        return event.sessionId.slice(0, 12) + "...";
+      }
+      /** 全タスクを取得（新しい順） */
+      getTasks() {
+        return [...this.tasks.values()].sort(
+          (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+        );
+      }
+      /** アクティブなタスク数を取得 */
+      getActiveCount() {
+        return [...this.tasks.values()].filter(
+          (t) => t.status === "running" || t.status === "pending"
+        ).length;
+      }
+      /** 手動でタスクを追加（会話内のツール実行など） */
+      track(taskId, sessionId, backendId, description) {
+        this.tasks.set(taskId, {
+          taskId,
+          sessionId,
+          backendId,
+          description,
+          status: "running",
+          createdAt: /* @__PURE__ */ new Date()
+        });
+        if (this.onUpdate) {
+          this.onUpdate(this.getTasks());
+        }
+      }
+      /** タスクを手動更新 */
+      updateTask(taskId, status, error) {
+        const task = this.tasks.get(taskId);
+        if (task) {
+          task.status = status;
+          if (status === "completed" || status === "failed") {
+            task.completedAt = /* @__PURE__ */ new Date();
+          }
+          if (error) task.error = error;
+          if (this.onUpdate) {
+            this.onUpdate(this.getTasks());
+          }
+        }
+      }
+      /** クリーンアップ */
+      cleanup() {
+        this.stopPolling();
+        this.tasks.clear();
+        this.lastEventId = null;
+      }
+    };
+  }
+});
+
+// src/tui/types.ts
+var types_exports = {};
+__export(types_exports, {
+  DEFAULT_TUI_CONFIG: () => DEFAULT_TUI_CONFIG
+});
+var DEFAULT_TUI_CONFIG;
+var init_types2 = __esm({
+  "src/tui/types.ts"() {
+    "use strict";
+    DEFAULT_TUI_CONFIG = {
+      backendSwitch: {
+        strategy: "shared-history",
+        contextSummaryMaxTokens: 2e3
+      },
+      display: {
+        showTokenCount: true,
+        showTimestamp: false
+      },
+      input: {
+        historySize: 100
+      }
+    };
+  }
+});
+
+// src/tui/services/tui-config-manager.ts
+var TUIConfigManager;
+var init_tui_config_manager = __esm({
+  "src/tui/services/tui-config-manager.ts"() {
+    "use strict";
+    init_types2();
+    TUIConfigManager = class {
+      constructor(configManager2) {
+        this.configManager = configManager2;
+      }
+      /**
+       * Load TUI configuration, deep-merging persisted values over defaults.
+       */
+      async load() {
+        const persisted = await this.configManager.get("tui");
+        if (!persisted) {
+          return { ...DEFAULT_TUI_CONFIG };
+        }
+        return {
+          backendSwitch: {
+            ...DEFAULT_TUI_CONFIG.backendSwitch,
+            ...persisted.backendSwitch ?? {}
+          },
+          display: {
+            ...DEFAULT_TUI_CONFIG.display,
+            ...persisted.display ?? {}
+          },
+          input: {
+            ...DEFAULT_TUI_CONFIG.input,
+            ...persisted.input ?? {}
+          }
+        };
+      }
+      /**
+       * Persist a TUI config value at the project scope.
+       *
+       * @param key   Dot-path relative to the `tui` section (e.g. "display.showTokenCount")
+       * @param value The value to store
+       */
+      async set(key, value) {
+        await this.configManager.set("project", `tui.${key}`, value);
+      }
+    };
+  }
+});
+
+// src/tui/components/TaskPanel.tsx
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function formatDuration(start, end) {
+  const ms = (end ?? /* @__PURE__ */ new Date()).getTime() - start.getTime();
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m${seconds % 60}s`;
+  return `${Math.floor(minutes / 60)}h${minutes % 60}m`;
+}
+function TaskPanel({ tasks, maxVisible = 10, selectedIndex }) {
+  const visibleTasks = tasks.slice(0, maxVisible);
+  return /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      flexDirection: "column",
+      width: 25,
+      borderStyle: "single",
+      borderLeft: true,
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsxs6(Box6, { marginBottom: 1, children: [
+          /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Tasks" }),
+          /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+            " (",
+            tasks.length,
+            ")"
+          ] })
+        ] }),
+        visibleTasks.length === 0 ? /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No tasks" }) : visibleTasks.map((task, index) => {
+          const indicator = STATUS_INDICATORS[task.status];
+          const duration = formatDuration(task.createdAt, task.completedAt);
+          const desc = task.description.length > 15 ? task.description.slice(0, 15) + "\u2026" : task.description;
+          const isSelected = index === selectedIndex;
+          const cursor = isSelected ? ">" : " ";
+          return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 0, children: [
+            /* @__PURE__ */ jsxs6(Box6, { children: [
+              /* @__PURE__ */ jsx7(Text7, { inverse: isSelected, children: cursor }),
+              /* @__PURE__ */ jsxs6(Text7, { color: indicator.color, inverse: isSelected, children: [
+                indicator.symbol,
+                " "
+              ] }),
+              /* @__PURE__ */ jsx7(Text7, { inverse: isSelected, children: desc })
+            ] }),
+            /* @__PURE__ */ jsx7(Box6, { marginLeft: 2, children: /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+              BACKEND_SHORT[task.backendId],
+              " ",
+              duration
+            ] }) })
+          ] }, task.taskId);
+        }),
+        tasks.length > maxVisible && /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+          "+",
+          tasks.length - maxVisible,
+          " more"
+        ] }),
+        /* @__PURE__ */ jsx7(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u2191\u2193:select r:retry x:cancel" }) })
+      ]
+    }
+  );
+}
+var STATUS_INDICATORS, BACKEND_SHORT;
+var init_TaskPanel = __esm({
+  "src/tui/components/TaskPanel.tsx"() {
+    "use strict";
+    STATUS_INDICATORS = {
+      pending: { symbol: "\u25CB", color: "gray" },
+      running: { symbol: "\u25CF", color: "yellow" },
+      completed: { symbol: "\u2713", color: "green" },
+      failed: { symbol: "\u2717", color: "red" },
+      stale: { symbol: "\u25CC", color: "gray" }
+    };
+    BACKEND_SHORT = {
+      claude: "CL",
+      codex: "CX",
+      gemini: "GM"
+    };
+  }
+});
+
+// src/tui/app.tsx
+var app_exports = {};
+__export(app_exports, {
+  App: () => App
+});
+import { useState, useEffect, useCallback } from "react";
+import { Box as Box7, Text as Text8, useInput, useApp } from "ink";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function App({ registry: registry2, sessionManager: sessionManager2, hooksEngine: hooksEngine2, contextMonitor: contextMonitor2, configManager: configManager2, initialBackend, model }) {
+  const { exit } = useApp();
+  const [messages, setMessages] = useState([]);
+  const [inputValue, setInputValue] = useState("");
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [streamingText, setStreamingText] = useState("");
+  const [activeBackend, setActiveBackend] = useState("claude");
+  const [sessionId, setSessionId] = useState();
+  const [tokenCount, setTokenCount] = useState({ input: 0, output: 0 });
+  const [tools, setTools] = useState([]);
+  const [statusMessage, setStatusMessage] = useState("");
+  const [error, setError] = useState(null);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [inputHistory, setInputHistory] = useState([]);
+  const [historyIndex, setHistoryIndex] = useState(-1);
+  const [backendStatuses, setBackendStatuses] = useState([]);
+  const [showTasks, setShowTasks] = useState(false);
+  const [tuiTasks, setTuiTasks] = useState([]);
+  const [taskSelectedIndex, setTaskSelectedIndex] = useState(0);
+  const [tuiConfigManager] = useState(() => new TUIConfigManager(configManager2));
+  const [tuiConfig, setTuiConfig] = useState(null);
+  const [engine] = useState(() => new ConversationEngine(registry2, sessionManager2, hooksEngine2, contextMonitor2));
+  const [orchestrator] = useState(() => new BackendOrchestrator(registry2, sessionManager2, hooksEngine2));
+  const [taskPoller] = useState(() => {
+    const eventStore = new AgentEventStore({ backend: "memory" });
+    return new TaskPoller(eventStore);
+  });
+  useEffect(() => {
+    void (async () => {
+      try {
+        const loadedConfig = await tuiConfigManager.load();
+        setTuiConfig(loadedConfig);
+        orchestrator.setStrategy(loadedConfig.backendSwitch.strategy);
+        const backendId = await orchestrator.initialize(initialBackend);
+        setActiveBackend(backendId);
+        const sid = await engine.initSession(backendId);
+        setSessionId(sid);
+        setBackendStatuses(orchestrator.getStatuses());
+        orchestrator.setSessionId(backendId, sid);
+        setIsInitialized(true);
+      } catch (e) {
+        setError(e instanceof Error ? e.message : String(e));
+      }
+    })();
+  }, []);
+  useEffect(() => {
+    if (!isInitialized) return;
+    taskPoller.setOnUpdate((tasks) => {
+      setTuiTasks(tasks);
+    });
+    taskPoller.startPolling(2e3);
+    return () => {
+      taskPoller.cleanup();
+    };
+  }, [isInitialized, taskPoller]);
+  const processInput = useCallback(async (text) => {
+    if (!text.trim() || isStreaming) return;
+    setIsStreaming(true);
+    setStreamingText("");
+    setTools([]);
+    setInputHistory((prev) => [text, ...prev].slice(0, 100));
+    setHistoryIndex(-1);
+    const userMsg = {
+      id: Date.now().toString(),
+      role: "user",
+      content: text,
+      timestamp: /* @__PURE__ */ new Date(),
+      backendId: activeBackend
+    };
+    setMessages((prev) => [...prev, userMsg]);
+    let fullText = "";
+    try {
+      for await (const event of engine.processInput(text, activeBackend)) {
+        switch (event.type) {
+          case "text":
+            fullText += event.text;
+            setStreamingText(fullText);
+            break;
+          case "tool_start":
+            setTools((prev) => [...prev, { id: event.id, tool: event.tool, status: "running" }]);
+            break;
+          case "tool_end":
+            setTools((prev) => prev.map((t) => t.id === event.id ? { ...t, status: event.result ? "completed" : "failed", result: event.result } : t));
+            break;
+          case "usage":
+            setTokenCount((prev) => ({ input: prev.input + event.inputTokens, output: prev.output + event.outputTokens }));
+            break;
+          case "error":
+            setStatusMessage(event.message);
+            break;
+          case "status":
+            setStatusMessage(event.message);
+            break;
+          case "done":
+            break;
+        }
+      }
+    } catch (e) {
+      setStatusMessage(e instanceof Error ? e.message : "An error occurred");
+    }
+    if (fullText) {
+      const assistantMsg = {
+        id: (Date.now() + 1).toString(),
+        role: "assistant",
+        content: fullText,
+        timestamp: /* @__PURE__ */ new Date(),
+        backendId: activeBackend
+      };
+      setMessages((prev) => [...prev, assistantMsg]);
+    }
+    setStreamingText("");
+    setIsStreaming(false);
+    setTokenCount(engine.getTotalTokens());
+  }, [isStreaming, activeBackend, engine]);
+  const switchBackend = useCallback(async (target) => {
+    if (isStreaming) return;
+    if (!orchestrator.isAvailable(target)) {
+      setStatusMessage(`Backend ${target} is not available`);
+      return;
+    }
+    if (orchestrator.getActiveId() === target) return;
+    try {
+      const { contextSummary } = await orchestrator.switchTo(target, engine.getMessages());
+      const sid = await engine.switchBackend(target, contextSummary);
+      setActiveBackend(target);
+      setSessionId(sid);
+      setTokenCount({ input: 0, output: 0 });
+      orchestrator.setSessionId(target, sid);
+      setBackendStatuses(orchestrator.getStatuses());
+      setMessages((prev) => [...prev, {
+        id: Date.now().toString(),
+        role: "system",
+        content: `Switched to ${target}${contextSummary ? " (with context)" : ""}`,
+        timestamp: /* @__PURE__ */ new Date(),
+        backendId: target
+      }]);
+      setStatusMessage(`Switched to ${target}`);
+    } catch (e) {
+      setStatusMessage(e instanceof Error ? e.message : "Switch failed");
+    }
+  }, [isStreaming, engine, orchestrator]);
+  const handleSlashCommand = useCallback(async (text) => {
+    const [cmd, ...argParts] = text.slice(1).split(" ");
+    const args = argParts.join(" ");
+    switch (cmd) {
+      case "help":
+        setMessages((prev) => [...prev, {
+          id: Date.now().toString(),
+          role: "system",
+          content: "Available commands:\n/help - Show this help\n/clear - Clear messages\n/backend <name> - Switch backend\n/model - Show current model\n/config [show|set <key> <value>|reset] - Manage TUI config\n/exit - Exit TUI",
+          timestamp: /* @__PURE__ */ new Date(),
+          backendId: activeBackend
+        }]);
+        break;
+      case "clear":
+        setMessages([]);
+        engine.clearMessages();
+        break;
+      case "backend":
+        if (args && ["claude", "codex", "gemini"].includes(args)) {
+          void switchBackend(args);
+        } else {
+          setStatusMessage("Usage: /backend <claude|codex|gemini>");
+        }
+        break;
+      case "model":
+        setMessages((prev) => [...prev, {
+          id: Date.now().toString(),
+          role: "system",
+          content: `Current backend: ${activeBackend}${model ? `, model: ${model}` : ""}`,
+          timestamp: /* @__PURE__ */ new Date(),
+          backendId: activeBackend
+        }]);
+        break;
+      case "config": {
+        const [subCmd, ...rest] = args.split(" ");
+        if (subCmd === "show" || !subCmd) {
+          const currentConfig = await tuiConfigManager.load();
+          setMessages((prev) => [...prev, {
+            id: Date.now().toString(),
+            role: "system",
+            content: "TUI Config:\n```json\n" + JSON.stringify(currentConfig, null, 2) + "\n```",
+            timestamp: /* @__PURE__ */ new Date(),
+            backendId: activeBackend
+          }]);
+        } else if (subCmd === "set" && rest.length >= 2) {
+          const key = rest[0];
+          const rawValue = rest.slice(1).join(" ");
+          let value = rawValue;
+          if (rawValue === "true") value = true;
+          else if (rawValue === "false") value = false;
+          else if (!isNaN(Number(rawValue))) value = Number(rawValue);
+          await tuiConfigManager.set(key, value);
+          const updated = await tuiConfigManager.load();
+          setTuiConfig(updated);
+          setStatusMessage(`Config updated: ${key} = ${JSON.stringify(value)}`);
+        } else if (subCmd === "reset") {
+          const { DEFAULT_TUI_CONFIG: DEFAULT_TUI_CONFIG2 } = await Promise.resolve().then(() => (init_types2(), types_exports));
+          for (const [section, sectionValue] of Object.entries(DEFAULT_TUI_CONFIG2)) {
+            for (const [k, v] of Object.entries(sectionValue)) {
+              await tuiConfigManager.set(`${section}.${k}`, v);
+            }
+          }
+          const updated = await tuiConfigManager.load();
+          setTuiConfig(updated);
+          setStatusMessage("Config reset to defaults");
+        } else {
+          setStatusMessage("Usage: /config [show|set <key> <value>|reset]");
+        }
+        break;
+      }
+      case "exit":
+        exit();
+        break;
+      default:
+        setStatusMessage(`Unknown command: /${cmd}`);
+    }
+  }, [activeBackend, model, engine, switchBackend, exit, tuiConfigManager]);
+  const handleSubmit = useCallback((text) => {
+    if (!text.trim()) return;
+    setInputValue("");
+    if (text.startsWith("/")) {
+      void handleSlashCommand(text);
+    } else {
+      void processInput(text);
+    }
+  }, [processInput, handleSlashCommand]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (isStreaming) {
+        setIsStreaming(false);
+        setStreamingText("");
+        setStatusMessage("Cancelled");
+      } else {
+        exit();
+      }
+      return;
+    }
+    if (key.ctrl && input === "d") {
+      exit();
+      return;
+    }
+    if (key.ctrl && input === "l") {
+      setMessages([]);
+      engine.clearMessages();
+      return;
+    }
+    if (key.ctrl && input === "1") {
+      void switchBackend("claude");
+      return;
+    }
+    if (key.ctrl && input === "2") {
+      void switchBackend("codex");
+      return;
+    }
+    if (key.ctrl && input === "3") {
+      void switchBackend("gemini");
+      return;
+    }
+    if (key.ctrl && input === "t") {
+      setShowTasks((prev) => !prev);
+      return;
+    }
+    if (showTasks) {
+      if (key.upArrow) {
+        setTaskSelectedIndex((prev) => Math.max(0, prev - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setTaskSelectedIndex((prev) => Math.min(tuiTasks.length - 1, prev + 1));
+        return;
+      }
+      if (input === "r") {
+        const selectedTask = tuiTasks[taskSelectedIndex];
+        if (selectedTask && (selectedTask.status === "failed" || selectedTask.status === "stale")) {
+          taskPoller.updateTask(selectedTask.taskId, "pending");
+        }
+        return;
+      }
+      if (input === "x") {
+        const selectedTask = tuiTasks[taskSelectedIndex];
+        if (selectedTask && selectedTask.status === "running") {
+          taskPoller.updateTask(selectedTask.taskId, "failed", "Cancelled by user");
+        }
+        return;
+      }
+    } else {
+      if (key.upArrow && !isStreaming && inputHistory.length > 0) {
+        const newIndex = Math.min(historyIndex + 1, inputHistory.length - 1);
+        setHistoryIndex(newIndex);
+        setInputValue(inputHistory[newIndex]);
+        return;
+      }
+      if (key.downArrow && !isStreaming) {
+        const newIndex = historyIndex - 1;
+        if (newIndex < 0) {
+          setHistoryIndex(-1);
+          setInputValue("");
+        } else {
+          setHistoryIndex(newIndex);
+          setInputValue(inputHistory[newIndex]);
+        }
+        return;
+      }
+    }
+  });
+  if (error) {
+    return /* @__PURE__ */ jsx8(Box7, { children: /* @__PURE__ */ jsxs7(Text8, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) });
+  }
+  if (!isInitialized) {
+    return /* @__PURE__ */ jsx8(Box7, { children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Initializing backends..." }) });
+  }
+  const activeTaskCount = tuiTasks.filter((t) => t.status === "running" || t.status === "pending").length;
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx8(
+      StatusBar,
+      {
+        backendId: activeBackend,
+        model,
+        sessionId,
+        tokenCount,
+        isStreaming,
+        showTokenCount: tuiConfig?.display.showTokenCount
+      }
+    ),
+    /* @__PURE__ */ jsxs7(Box7, { flexGrow: 1, flexDirection: "row", children: [
+      /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx8(
+          ChatView,
+          {
+            messages,
+            streamingText,
+            isStreaming
+          }
+        ),
+        tools.length > 0 && /* @__PURE__ */ jsx8(ToolProgress, { tools })
+      ] }),
+      showTasks && /* @__PURE__ */ jsx8(
+        TaskPanel,
+        {
+          tasks: tuiTasks,
+          selectedIndex: taskSelectedIndex,
+          onRetry: (task) => {
+            taskPoller.updateTask(task.taskId, "pending");
+          },
+          onCancel: (task) => {
+            taskPoller.updateTask(task.taskId, "failed", "Cancelled by user");
+          }
+        }
+      )
+    ] }),
+    statusMessage && /* @__PURE__ */ jsx8(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: statusMessage }) }),
+    /* @__PURE__ */ jsx8(
+      InputArea,
+      {
+        value: inputValue,
+        onChange: setInputValue,
+        onSubmit: handleSubmit,
+        isDisabled: isStreaming
+      }
+    ),
+    /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx8(
+        BackendIndicator,
+        {
+          statuses: backendStatuses,
+          activeBackendId: activeBackend
+        }
+      ),
+      /* @__PURE__ */ jsxs7(Box7, { marginLeft: 2, children: [
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "^T " }),
+        /* @__PURE__ */ jsx8(Text8, { bold: showTasks, children: "Tasks" }),
+        activeTaskCount > 0 && /* @__PURE__ */ jsxs7(Text8, { color: "yellow", children: [
+          "(",
+          activeTaskCount,
+          ")"
+        ] })
+      ] })
+    ] })
+  ] });
+}
+var init_app = __esm({
+  "src/tui/app.tsx"() {
+    "use strict";
+    init_conversation_engine();
+    init_backend_orchestrator();
+    init_StatusBar();
+    init_ChatView();
+    init_InputArea();
+    init_ToolProgress();
+    init_BackendIndicator();
+    init_agent_event_store();
+    init_task_poller();
+    init_tui_config_manager();
+    init_TaskPanel();
+  }
+});
+
 // src/bin/relay.ts
-import { defineCommand as defineCommand10, runMain } from "citty";
+import { defineCommand as defineCommand11, runMain } from "citty";
 import { join as join11 } from "path";
 import { homedir as homedir7 } from "os";
 
@@ -4617,7 +5877,20 @@ var relayConfigSchema = z.object({
   telemetry: z.object({
     enabled: z.boolean()
   }).optional(),
-  claudePermissionMode: z.enum(["default", "bypassPermissions"]).optional()
+  claudePermissionMode: z.enum(["default", "bypassPermissions"]).optional(),
+  tui: z.object({
+    backendSwitch: z.object({
+      strategy: z.enum(["isolated", "shared-history", "full-transfer"]).optional(),
+      contextSummaryMaxTokens: z.number().positive().optional()
+    }).optional(),
+    display: z.object({
+      showTokenCount: z.boolean().optional(),
+      showTimestamp: z.boolean().optional()
+    }).optional(),
+    input: z.object({
+      historySize: z.number().int().positive().optional()
+    }).optional()
+  }).optional()
 });
 
 // src/core/config-manager.ts
@@ -6212,7 +7485,7 @@ function createVersionCommand(registry2) {
       description: "Show relay and backend versions"
     },
     async run() {
-      const relayVersion = "1.3.1";
+      const relayVersion = "1.4.1";
       console.log(`agentic-relay v${relayVersion}`);
       console.log("");
       console.log("Backends:");
@@ -6536,6 +7809,48 @@ function createInitCommand() {
   });
 }
 
+// src/commands/interactive.ts
+import { defineCommand as defineCommand10 } from "citty";
+function createInteractiveCommand(registry2, sessionManager2, hooksEngine2, contextMonitor2, configManager2) {
+  return defineCommand10({
+    meta: {
+      name: "interactive",
+      description: "Start interactive TUI mode"
+    },
+    args: {
+      backend: {
+        type: "string",
+        alias: "b",
+        description: "Initial backend (claude, codex, gemini)"
+      },
+      model: {
+        type: "string",
+        alias: "m",
+        description: "Model to use"
+      }
+    },
+    async run({ args }) {
+      const { render } = await import("ink");
+      const { createElement } = await import("react");
+      const { App: App2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+      const initialBackend = args.backend;
+      const model = args.model;
+      const { waitUntilExit } = render(
+        createElement(App2, {
+          registry: registry2,
+          sessionManager: sessionManager2,
+          hooksEngine: hooksEngine2,
+          contextMonitor: contextMonitor2,
+          configManager: configManager2,
+          initialBackend,
+          model
+        })
+      );
+      await waitUntilExit();
+    }
+  });
+}
+
 // src/bin/relay.ts
 init_logger();
 var processManager = new ProcessManager();
@@ -6562,12 +7877,40 @@ void configManager.getConfig().then((config) => {
     });
   }
 }).catch((e) => logger.debug("Config load failed:", e));
-var main = defineCommand10({
+var interactiveCmd = createInteractiveCommand(registry, sessionManager, hooksEngine, contextMonitor, configManager);
+var subCommandNames = /* @__PURE__ */ new Set(["claude", "codex", "gemini", "update", "config", "mcp", "auth", "sessions", "version", "doctor", "init"]);
+var main = defineCommand11({
   meta: {
     name: "relay",
-    version: "1.3.1",
+    version: "1.4.1",
     description: "Unified CLI proxy for Claude Code, Codex CLI, and Gemini CLI"
   },
+  args: {
+    backend: {
+      type: "string",
+      alias: "b",
+      description: "Initial backend for interactive mode (claude, codex, gemini)"
+    },
+    model: {
+      type: "string",
+      alias: "m",
+      description: "Model to use in interactive mode"
+    }
+  },
+  async run({ args }) {
+    const hasSubCommand = process.argv.slice(2).some((arg) => subCommandNames.has(arg));
+    if (hasSubCommand) return;
+    const interactiveArgs = {
+      backend: args.backend ?? "",
+      model: args.model ?? ""
+    };
+    await interactiveCmd.run({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: interactiveArgs,
+      rawArgs: [],
+      cmd: interactiveCmd
+    });
+  },
   subCommands: {
     claude: createBackendCommand("claude", registry, sessionManager, hooksEngine, contextMonitor),
     codex: createBackendCommand("codex", registry, sessionManager, hooksEngine, contextMonitor),