cueclaw 0.1.2 → 0.1.4

package/dist/app-6SXWEUZZ.js

@@ -0,0 +1,3289 @@
+import {
+  MessageRouter,
+  TriggerLoop,
+  isDaemonRunning,
+  isProcessAlive,
+  readPidFile,
+  removePidFile,
+  spawnDaemonProcess
+} from "./chunk-54BGF7G5.js";
+import {
+  getServiceStatus
+} from "./chunk-MEAAX2SW.js";
+import {
+  checkEnvironment,
+  validateAuth
+} from "./chunk-FKKDQVRE.js";
+import {
+  askQuestionTool,
+  buildPlannerSystemPrompt,
+  confirmPlan,
+  parsePlannerToolResponse,
+  plannerTool,
+  rejectPlan,
+  setSecretTool
+} from "./chunk-ZOFGQYXX.js";
+import {
+  createAnthropicClient
+} from "./chunk-DVQFSFIZ.js";
+import {
+  executeWorkflow
+} from "./chunk-3HV3MHME.js";
+import {
+  deleteWorkflow,
+  getStepRunsByRunId,
+  getWorkflow,
+  getWorkflowRunsByWorkflowId,
+  initDb,
+  listWorkflows,
+  updateWorkflowPhase,
+  upsertWorkflow
+} from "./chunk-HKZ6IN7X.js";
+import {
+  cueclawHome,
+  loadConfig,
+  loadExistingConfig,
+  validateConfig,
+  writeConfig
+} from "./chunk-5TV4LNC3.js";
+import "./chunk-BVQG3WYO.js";
+import {
+  isDev,
+  writeEnvVar
+} from "./chunk-ZCK3IFLC.js";
+import {
+  logger,
+  onLogLine
+} from "./chunk-KBLMQZ3P.js";
+
+// src/tui/app.tsx
+import { ThemeProvider } from "@inkjs/ui";
+
+// src/tui/theme.ts
+import { extendTheme, defaultTheme } from "@inkjs/ui";
+
+// src/tui/theme/semantic-colors.ts
+function buildSemanticColors(palette) {
+  return {
+    text: {
+      primary: palette.Foreground,
+      secondary: palette.ForegroundDim,
+      accent: palette.AccentCyan,
+      user: palette.Foreground,
+      response: palette.Foreground,
+      link: palette.AccentBlue
+    },
+    status: {
+      success: palette.AccentGreen,
+      warning: palette.AccentYellow,
+      error: palette.AccentRed,
+      info: palette.AccentCyan,
+      muted: palette.ForegroundDim
+    },
+    border: {
+      default: palette.Border,
+      accent: palette.BorderAccent,
+      focused: palette.AccentBlue
+    },
+    background: {
+      primary: palette.Background,
+      message: palette.MessageBackground,
+      input: palette.InputBackground
+    },
+    ui: {
+      comment: palette.Comment,
+      gradient: palette.GradientColors
+    },
+    prompt: palette.AccentGreen
+  };
+}
+
+// src/tui/color-utils.ts
+function hexToRgb(hex) {
+  const h = hex.replace("#", "");
+  return [
+    parseInt(h.slice(0, 2), 16),
+    parseInt(h.slice(2, 4), 16),
+    parseInt(h.slice(4, 6), 16)
+  ];
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map((c) => Math.round(c).toString(16).padStart(2, "0")).join("");
+}
+function interpolateColor(base, overlay, opacity) {
+  const [br, bg, bb] = hexToRgb(base);
+  const [or, og, ob] = hexToRgb(overlay);
+  return rgbToHex(
+    br + (or - br) * opacity,
+    bg + (og - bg) * opacity,
+    bb + (ob - bb) * opacity
+  );
+}
+
+// src/tui/theme/themes.ts
+var darkTheme = {
+  name: "dark",
+  type: "dark",
+  Foreground: "#CDD6F4",
+  ForegroundDim: "#6C7086",
+  Background: "#1E1E2E",
+  AccentCyan: "#89DCEB",
+  AccentGreen: "#A6E3A1",
+  AccentYellow: "#F9E2AF",
+  AccentRed: "#F38BA8",
+  AccentBlue: "#89B4FA",
+  AccentMagenta: "#CBA6F7",
+  Border: interpolateColor("#1E1E2E", "#6C7086", 0.4),
+  BorderAccent: "#89B4FA",
+  Comment: "#6C7086",
+  MessageBackground: interpolateColor("#1E1E2E", "#6C7086", 0.12),
+  InputBackground: interpolateColor("#1E1E2E", "#6C7086", 0.08),
+  GradientColors: ["#4796E4", "#847ACE", "#C3677F"]
+};
+var lightTheme = {
+  name: "light",
+  type: "light",
+  Foreground: "#4C4F69",
+  ForegroundDim: "#9CA0B0",
+  Background: "#EFF1F5",
+  AccentCyan: "#04A5E5",
+  AccentGreen: "#40A02B",
+  AccentYellow: "#DF8E1D",
+  AccentRed: "#D20F39",
+  AccentBlue: "#1E66F5",
+  AccentMagenta: "#8839EF",
+  Border: interpolateColor("#EFF1F5", "#9CA0B0", 0.4),
+  BorderAccent: "#1E66F5",
+  Comment: "#9CA0B0",
+  MessageBackground: interpolateColor("#EFF1F5", "#9CA0B0", 0.12),
+  InputBackground: interpolateColor("#EFF1F5", "#9CA0B0", 0.08),
+  GradientColors: ["#1E66F5", "#8839EF", "#D20F39"]
+};
+var draculaTheme = {
+  name: "dracula",
+  type: "dark",
+  Foreground: "#f8f8f2",
+  ForegroundDim: "#6272a4",
+  Background: "#282a36",
+  AccentCyan: "#8be9fd",
+  AccentGreen: "#50fa7b",
+  AccentYellow: "#f1fa8c",
+  AccentRed: "#ff5555",
+  AccentBlue: "#6272a4",
+  AccentMagenta: "#ff79c6",
+  Border: interpolateColor("#282a36", "#6272a4", 0.4),
+  BorderAccent: "#bd93f9",
+  Comment: "#6272a4",
+  MessageBackground: interpolateColor("#282a36", "#6272a4", 0.12),
+  InputBackground: interpolateColor("#282a36", "#6272a4", 0.08),
+  GradientColors: ["#bd93f9", "#ff79c6", "#ff5555"]
+};
+var builtinThemes = {
+  dark: darkTheme,
+  light: lightTheme,
+  dracula: draculaTheme
+};
+
+// src/tui/theme/theme-manager.ts
+var currentSemanticColors = buildSemanticColors(darkTheme);
+var currentThemeName = "dark";
+var version = 0;
+var themeManager = {
+  getSemanticColors() {
+    return currentSemanticColors;
+  },
+  getThemeName() {
+    return currentThemeName;
+  },
+  getVersion() {
+    return version;
+  },
+  setTheme(name) {
+    const palette = builtinThemes[name];
+    if (!palette) return false;
+    currentSemanticColors = buildSemanticColors(palette);
+    currentThemeName = name;
+    version++;
+    return true;
+  },
+  getAvailableThemes() {
+    return Object.keys(builtinThemes);
+  }
+};
+
+// src/tui/theme/index.ts
+var theme = new Proxy({}, {
+  get(_target, prop) {
+    return themeManager.getSemanticColors()[prop];
+  }
+});
+
+// src/tui/theme.ts
+var cueclawTheme = extendTheme(defaultTheme, {
+  components: {
+    Header: {
+      styles: {
+        hints: () => ({ color: theme.text.primary, dimColor: true })
+      }
+    },
+    PlanView: {
+      styles: {
+        title: () => ({ color: theme.border.accent, bold: true }),
+        stepPending: () => ({ color: theme.status.muted }),
+        stepRunning: () => ({ color: theme.status.warning }),
+        stepDone: () => ({ color: theme.status.success }),
+        stepFailed: () => ({ color: theme.status.error }),
+        border: () => ({ borderColor: theme.border.default })
+      }
+    },
+    StatusDashboard: {
+      styles: {
+        executing: () => ({ color: theme.status.warning }),
+        completed: () => ({ color: theme.status.success }),
+        failed: () => ({ color: theme.status.error }),
+        paused: () => ({ color: theme.status.muted, dimColor: true })
+      }
+    },
+    Chat: {
+      styles: {
+        userMessage: () => ({ color: theme.text.user, bold: true }),
+        systemMessage: () => ({ color: theme.status.info }),
+        assistantMessage: () => ({ color: theme.text.primary }),
+        prompt: () => ({ color: theme.prompt })
+      }
+    }
+  }
+});
+
+// src/tui/use-keypress.tsx
+import { createContext, useContext, useRef, useCallback, useEffect } from "react";
+import { useInput } from "ink";
+import { jsx } from "react/jsx-runtime";
+var KeyPriority = {
+  Low: 0,
+  Normal: 100,
+  High: 200,
+  Critical: 300
+};
+var KeypressContext = createContext(null);
+function KeypressProvider({ children }) {
+  const handlersRef = useRef([]);
+  const register = useCallback((entry) => {
+    handlersRef.current = [...handlersRef.current.filter((h) => h.id !== entry.id), entry];
+  }, []);
+  const unregister = useCallback((id) => {
+    handlersRef.current = handlersRef.current.filter((h) => h.id !== id);
+  }, []);
+  const update = useCallback((id, patch) => {
+    handlersRef.current = handlersRef.current.map(
+      (h) => h.id === id ? { ...h, ...patch } : h
+    );
+  }, []);
+  useInput((input, key) => {
+    const sorted = [...handlersRef.current].filter((h) => h.isActive).sort((a, b) => b.priority - a.priority);
+    for (const entry of sorted) {
+      const consumed = entry.handler(input, key);
+      if (consumed === true) break;
+    }
+  });
+  return /* @__PURE__ */ jsx(KeypressContext.Provider, { value: { register, unregister, update }, children });
+}
+var nextId = 0;
+function useKeypress(id, priority, handler, isActive = true) {
+  const ctx = useContext(KeypressContext);
+  const stableId = useRef(id || `keypress-${nextId++}`).current;
+  useEffect(() => {
+    if (!ctx) return;
+    ctx.register({ id: stableId, priority, handler, isActive });
+    return () => ctx.unregister(stableId);
+  }, [ctx, stableId]);
+  useEffect(() => {
+    if (!ctx) return;
+    ctx.update(stableId, { handler, isActive });
+  }, [ctx, stableId, handler, isActive]);
+}
+
+// src/tui/dialog-manager.tsx
+import { createContext as createContext2, useContext as useContext2, useState, useCallback as useCallback2 } from "react";
+import { Box, Text } from "ink";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var DialogPriority = {
+  Normal: 0,
+  High: 100,
+  Critical: 200
+};
+var DialogContext = createContext2(null);
+function useDialog() {
+  const ctx = useContext2(DialogContext);
+  if (!ctx) throw new Error("useDialog must be used within DialogManager");
+  return ctx;
+}
+function DialogOverlay({ dialog, onDismiss }) {
+  useKeypress("dialog-overlay", KeyPriority.Critical, useCallback2((input, key) => {
+    for (const action of dialog.actions) {
+      if (input.toLowerCase() === action.key.toLowerCase()) {
+        action.handler();
+        return true;
+      }
+    }
+    if (key.escape) {
+      onDismiss();
+      return true;
+    }
+    return true;
+  }, [dialog.actions, onDismiss]));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border.focused, paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx2(Text, { bold: true, color: theme.status.warning, children: dialog.title }),
+    /* @__PURE__ */ jsx2(Text, { color: theme.text.primary, children: dialog.message }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, gap: 2, children: [
+      dialog.actions.map((action) => /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: theme.text.accent, children: [
+          "[",
+          action.key.toUpperCase(),
+          "]"
+        ] }),
+        " ",
+        action.label
+      ] }, action.key)),
+      /* @__PURE__ */ jsx2(Text, { color: theme.ui.comment, children: "[Esc] Dismiss" })
+    ] })
+  ] });
+}
+function DialogManager({ children }) {
+  const [dialogQueue, setDialogQueue] = useState([]);
+  const showDialog = useCallback2((dialog) => {
+    setDialogQueue((prev) => {
+      const next = [...prev, dialog];
+      next.sort((a, b) => (b.priority ?? DialogPriority.Normal) - (a.priority ?? DialogPriority.Normal));
+      return next;
+    });
+  }, []);
+  const dismissDialog = useCallback2(() => {
+    setDialogQueue((prev) => prev.slice(1));
+  }, []);
+  const activeDialog = dialogQueue[0] ?? null;
+  return /* @__PURE__ */ jsxs(DialogContext.Provider, { value: { showDialog, dismissDialog }, children: [
+    children,
+    activeDialog && /* @__PURE__ */ jsx2(DialogOverlay, { dialog: activeDialog, onDismiss: dismissDialog })
+  ] });
+}
+
+// src/tui/app-provider.tsx
+import { useReducer, useCallback as useCallback7, useMemo as useMemo2, useState as useState4, useEffect as useEffect3 } from "react";
+import { useApp } from "ink";
+
+// src/tui/ui-state-context.ts
+import { createContext as createContext3, useContext as useContext3 } from "react";
+var UIStateContext = createContext3(null);
+function useUIState() {
+  const ctx = useContext3(UIStateContext);
+  if (!ctx) throw new Error("useUIState must be used within an AppProvider");
+  return ctx;
+}
+
+// src/tui/ui-actions-context.ts
+import { createContext as createContext4, useContext as useContext4 } from "react";
+var UIActionsContext = createContext4(null);
+function useUIActions() {
+  const ctx = useContext4(UIActionsContext);
+  if (!ctx) throw new Error("useUIActions must be used within an AppProvider");
+  return ctx;
+}
+
+// src/tui/hooks/use-daemon-bridge.ts
+import { useState as useState2, useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// src/tui/daemon-bridge.ts
+var externalBridge = {
+  triggerLoop: null,
+  router: null,
+  botChannels: [],
+  botConnectResult: null,
+  isExternal: true
+};
+function waitForDaemon(pid, maxWaitMs) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const check = () => {
+      if (isProcessAlive(pid)) return resolve(true);
+      if (Date.now() - start > maxWaitMs) return resolve(false);
+      setTimeout(check, 200);
+    };
+    check();
+  });
+}
+async function initDaemonBridge(db, config, cwd, options) {
+  const serviceRunning = getServiceStatus() === "running";
+  const pidDaemonRunning = isDaemonRunning();
+  if (serviceRunning || pidDaemonRunning) {
+    logger.info({ via: serviceRunning ? "service" : "pid" }, "External daemon detected, TUI will operate as frontend only");
+    return externalBridge;
+  }
+  const pid = spawnDaemonProcess();
+  if (pid) {
+    const alive = await waitForDaemon(pid, 2e3);
+    if (alive) {
+      logger.info({ pid }, "Background daemon started, TUI will operate as frontend only");
+      return externalBridge;
+    }
+    logger.warn({ pid }, "Spawned daemon process died, falling back to in-process mode");
+  } else {
+    logger.warn("Failed to spawn background daemon, falling back to in-process mode");
+  }
+  const router = new MessageRouter(db, config, cwd);
+  const botChannels = [];
+  let botConnectResult = null;
+  if (!options?.skipBots) {
+    botConnectResult = await connectBotChannels(config, router, botChannels);
+  }
+  const triggerLoop = new TriggerLoop(db, router, cwd, 5);
+  triggerLoop.start();
+  router.start();
+  logger.info("In-process daemon bridge started (fallback)");
+  return {
+    triggerLoop,
+    router,
+    botChannels,
+    botConnectResult,
+    isExternal: false
+  };
+}
+async function startBotChannels(bridge, config) {
+  if (bridge.isExternal || !bridge.router) return;
+  await connectBotChannels(config, bridge.router, bridge.botChannels);
+}
+async function connectBotChannels(config, router, botChannels) {
+  const connected = [];
+  const failed = [];
+  if (config.telegram?.enabled && config.telegram.token) {
+    try {
+      const { TelegramChannel } = await import("./telegram-FH5O4F3K.js");
+      const tg = new TelegramChannel(
+        config.telegram.token,
+        config.telegram.allowed_users ?? [],
+        (jid, msg) => router.handleInbound("telegram", jid, msg)
+      );
+      router.registerChannel(tg);
+      await tg.connect();
+      tg.onCallback((wfId, action, chatId) => router.handleCallbackAction("telegram", chatId, wfId, action));
+      botChannels.push(tg);
+      connected.push("Telegram");
+      logger.info("Telegram channel started (in-process)");
+    } catch (err) {
+      failed.push("Telegram");
+      logger.error({ err }, "Failed to start Telegram channel");
+    }
+  }
+  if (config.whatsapp?.enabled) {
+    try {
+      const { WhatsAppChannel } = await import("./whatsapp-RLNSXSFI.js");
+      const wa = new WhatsAppChannel(
+        config.whatsapp.auth_dir ?? `${process.env["HOME"]}/.cueclaw/auth/whatsapp`,
+        config.whatsapp.allowed_jids ?? [],
+        (jid, msg) => router.handleInbound("whatsapp", jid, msg)
+      );
+      router.registerChannel(wa);
+      await wa.connect();
+      botChannels.push(wa);
+      connected.push("WhatsApp");
+      logger.info("WhatsApp channel started (in-process)");
+    } catch (err) {
+      failed.push("WhatsApp");
+      logger.error({ err }, "Failed to start WhatsApp channel");
+    }
+  }
+  return { connected, failed };
+}
+async function stopDaemonBridge(bridge) {
+  if (bridge.isExternal) return;
+  bridge.triggerLoop?.stop();
+  bridge.router?.stop();
+  for (const channel of bridge.botChannels) {
+    try {
+      await channel.disconnect();
+    } catch (err) {
+      logger.error({ err, channel: channel.name }, "Failed to disconnect channel");
+    }
+  }
+  logger.info("Daemon bridge stopped");
+}
+function stopExternalDaemon() {
+  const pid = readPidFile();
+  if (pid && isProcessAlive(pid)) {
+    process.kill(pid, "SIGTERM");
+    removePidFile();
+    logger.info({ pid }, "Stopped external daemon");
+  }
+}
+
+// src/tui/hooks/use-daemon-bridge.ts
+function useDaemonBridge(config, db, cwd, dispatch) {
+  const bridgeRef = useRef2(null);
+  const [daemonStatus, setDaemonStatus] = useState2("none");
+  const hasConfiguredBots = !!(config?.telegram?.enabled && config?.telegram?.token || config?.whatsapp?.enabled);
+  useEffect2(() => {
+    if (!config) return;
+    let cancelled = false;
+    setDaemonStatus("starting");
+    dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: "Starting daemon..." } });
+    initDaemonBridge(db, config, cwd, { skipBots: !hasConfiguredBots }).then((bridge) => {
+      if (cancelled) {
+        stopDaemonBridge(bridge);
+        return;
+      }
+      bridgeRef.current = bridge;
+      setDaemonStatus(bridge.isExternal ? "external" : "running");
+      dispatch({
+        type: "ADD_MESSAGE",
+        message: {
+          type: "system",
+          text: bridge.isExternal ? "Background daemon running." : "Daemon started (in-process)."
+        }
+      });
+      if (!bridge.isExternal && bridge.botConnectResult) {
+        const { connected, failed } = bridge.botConnectResult;
+        if (connected.length > 0) {
+          dispatch({
+            type: "ADD_MESSAGE",
+            message: { type: "system", text: `${connected.join(", ")} bot${connected.length > 1 ? "s" : ""} connected.` }
+          });
+        }
+        if (failed.length > 0) {
+          dispatch({
+            type: "ADD_MESSAGE",
+            message: { type: "error", text: `Failed to connect: ${failed.join(", ")}. Check logs for details.` }
+          });
+        }
+      }
+    }).catch((err) => {
+      logger.error({ err }, "Failed to start daemon bridge");
+      setDaemonStatus("none");
+      dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: "Failed to start daemon." } });
+    });
+    return () => {
+      cancelled = true;
+      if (bridgeRef.current) {
+        stopDaemonBridge(bridgeRef.current);
+        bridgeRef.current = null;
+      }
+    };
+  }, [config, db, cwd]);
+  return { bridgeRef, daemonStatus };
+}
+
+// src/tui/hooks/use-planner-session.ts
+import { useCallback as useCallback3, useRef as useRef3 } from "react";
+
+// src/planner-session.ts
+import { nanoid } from "nanoid";
+async function startPlannerSession(userMessage, config, callbacks, channelContext) {
+  const session = {
+    id: `ps_${nanoid()}`,
+    messages: [{ role: "user", content: userMessage }],
+    status: "conversing",
+    workflow: null
+  };
+  logger.info({ sessionId: session.id }, "Planner session started");
+  const turn = await runPlannerTurn(session, config, callbacks, channelContext);
+  return { session, turn };
+}
+async function continuePlannerSession(session, userMessage, config, callbacks, channelContext) {
+  session.messages.push({ role: "user", content: userMessage });
+  logger.debug({ sessionId: session.id, turnCount: session.messages.length }, "Planner session continued");
+  const turn = await runPlannerTurn(session, config, callbacks, channelContext);
+  return { session, turn };
+}
+function cancelPlannerSession(session) {
+  session.status = "cancelled";
+  logger.info({ sessionId: session.id }, "Planner session cancelled");
+}
+async function runPlannerTurn(session, config, callbacks, channelContext) {
+  const anthropic = createAnthropicClient(config);
+  const systemPrompt = buildPlannerSystemPrompt(config, channelContext) + `
+
+## Conversation Mode
+
+You are in multi-turn conversation mode. You have three tools:
+
+1. **ask_question** \u2014 Ask the user clarifying questions when more information is needed.
+   Use this when the user's description is vague, missing key details (trigger type, frequency, target repos, filters, output format, etc.), or could be interpreted multiple ways.
+   Also use this to ask the user for missing credentials \u2014 e.g., "This workflow needs a GITHUB_TOKEN. Could you provide one?"
+
+2. **set_secret** \u2014 Store a credential the user provides (e.g., API token, webhook URL).
+   Only call this AFTER the user explicitly provides the secret value. Never guess or fabricate values.
+
+3. **create_workflow** \u2014 Generate the final workflow plan when you have sufficient information.
+   Only use this when you are confident you understand the user's requirements.
+
+Guidelines:
+- For simple, clear requests, you may generate the plan immediately.
+- For complex or ambiguous requests, ask 1-3 focused questions first.
+- If a workflow requires credentials not listed in Available Credentials, ask the user for them before creating the workflow.
+- Be concise and helpful in your questions.
+- Respond in the same language the user uses.`;
+  let response;
+  try {
+    if (callbacks?.onToken) {
+      const stream = anthropic.messages.stream({
+        model: config.claude.planner.model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: session.messages,
+        tools: [askQuestionTool, setSecretTool, plannerTool]
+      });
+      stream.on("text", (text) => {
+        callbacks.onToken?.(text);
+      });
+      response = await stream.finalMessage();
+    } else {
+      response = await anthropic.messages.create({
+        model: config.claude.planner.model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: session.messages,
+        tools: [askQuestionTool, setSecretTool, plannerTool]
+      });
+    }
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    logger.error({ err }, "Planner session API request failed");
+    return { type: "error", content: `API request failed: ${detail}` };
+  }
+  const rawResponse = response;
+  if (rawResponse.type === "error" || rawResponse.error) {
+    const errMsg = rawResponse.error?.message ?? JSON.stringify(rawResponse.error ?? rawResponse);
+    return { type: "error", content: `API error: ${errMsg}` };
+  }
+  const result = parsePlannerToolResponse(response);
+  session.messages.push({ role: "assistant", content: response.content });
+  switch (result.type) {
+    case "question": {
+      logger.debug({ sessionId: session.id }, "Planner asking clarifying question");
+      const toolBlock = response.content.find((b) => b.type === "tool_use" && b.name === "ask_question");
+      if (toolBlock && toolBlock.type === "tool_use") {
+        session.messages.push({
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: toolBlock.id, content: "Question delivered to user. Waiting for response." }]
+        });
+      }
+      return { type: "question", content: result.question };
+    }
+    case "set_secret": {
+      if (isDev) {
+        writeEnvVar(result.key, result.value);
+      } else {
+        process.env[result.key] = result.value;
+      }
+      logger.info({ key: result.key }, "Secret stored via planner");
+      const secretToolBlock = response.content.find((b) => b.type === "tool_use" && b.name === "set_secret");
+      if (secretToolBlock && secretToolBlock.type === "tool_use") {
+        session.messages.push({
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: secretToolBlock.id, content: `Secret ${result.key} saved successfully.` }]
+        });
+      }
+      return runPlannerTurn(session, config, callbacks, channelContext);
+    }
+    case "plan": {
+      logger.info({ sessionId: session.id }, "Planner generated plan");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const workflow = {
+        ...result.plannerOutput,
+        schema_version: "1.0",
+        id: `wf_${nanoid()}`,
+        phase: "awaiting_confirmation",
+        created_at: now,
+        updated_at: now
+      };
+      session.workflow = workflow;
+      session.status = "plan_ready";
+      return { type: "plan", content: `Generated plan: "${workflow.name}"`, workflow };
+    }
+    case "text":
+      return { type: "text", content: result.text };
+    case "error":
+      logger.error({ sessionId: session.id, error: result.error }, "Planner session turn error");
+      return { type: "error", content: result.error };
+  }
+}
+
+// src/tui/hooks/use-planner-session.ts
+function usePlannerSession(config, dispatch, streamingText) {
+  const plannerSessionRef = useRef3(null);
+  const handleUserMessage = useCallback3(async (text) => {
+    if (!config) return;
+    dispatch({ type: "ADD_MESSAGE", message: { type: "user", text } });
+    dispatch({ type: "SET_GENERATING", value: true });
+    dispatch({ type: "SET_STREAMING_TEXT", text: "" });
+    try {
+      let result;
+      const tuiContext = { channel: "tui" };
+      if (plannerSessionRef.current && plannerSessionRef.current.status === "conversing") {
+        result = await continuePlannerSession(
+          plannerSessionRef.current,
+          text,
+          config,
+          {
+            onToken: (token) => {
+              dispatch({ type: "SET_STREAMING_TEXT", text: (streamingText || "") + token });
+            }
+          },
+          tuiContext
+        );
+      } else {
+        result = await startPlannerSession(
+          text,
+          config,
+          {
+            onToken: (token) => {
+              dispatch({ type: "SET_STREAMING_TEXT", text: (streamingText || "") + token });
+            }
+          },
+          tuiContext
+        );
+      }
+      plannerSessionRef.current = result.session;
+      dispatch({ type: "SET_STREAMING_TEXT", text: "" });
+      switch (result.turn.type) {
+        case "question":
+          dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: result.turn.content } });
+          dispatch({ type: "SET_GENERATING", value: false });
+          break;
+        case "plan":
+          if (result.turn.workflow) {
+            dispatch({ type: "ADD_MESSAGE", message: { type: "plan-ready", workflowName: result.turn.workflow.name } });
+            dispatch({ type: "SET_GENERATING", value: false });
+            dispatch({ type: "SHOW_PLAN", workflow: result.turn.workflow });
+          }
+          break;
+        case "text":
+          dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: result.turn.content } });
+          dispatch({ type: "SET_GENERATING", value: false });
+          break;
+        case "error":
+          dispatch({ type: "ADD_MESSAGE", message: { type: "error", text: `Error: ${result.turn.content}` } });
+          dispatch({ type: "SET_GENERATING", value: false });
+          plannerSessionRef.current = null;
+          break;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      dispatch({ type: "ADD_MESSAGE", message: { type: "error", text: `Error: ${msg}` } });
+      dispatch({ type: "SET_GENERATING", value: false });
+      dispatch({ type: "SET_STREAMING_TEXT", text: "" });
+      plannerSessionRef.current = null;
+      logger.error({ err }, "Planner session failed");
+    }
+  }, [config, streamingText]);
+  const handleCancelGeneration = useCallback3(() => {
+    if (plannerSessionRef.current) {
+      cancelPlannerSession(plannerSessionRef.current);
+      plannerSessionRef.current = null;
+    }
+    dispatch({ type: "SET_STREAMING_TEXT", text: "" });
+    dispatch({ type: "SET_GENERATING", value: false });
+    dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: "Generation cancelled." } });
+  }, []);
+  const isConversing = plannerSessionRef.current?.status === "conversing";
+  return { plannerSessionRef, handleUserMessage, handleCancelGeneration, isConversing };
+}
+
+// src/tui/hooks/use-workflow-execution.ts
+import { useCallback as useCallback4, useRef as useRef4, useState as useState3 } from "react";
+function useWorkflowExecution(workflow, db, cwd, bridgeRef, plannerSessionRef, dispatch) {
+  const abortRef = useRef4(null);
+  const abortMapRef = useRef4(/* @__PURE__ */ new Map());
+  const [isExecuting, setIsExecuting] = useState3(false);
+  const handleConfirm = useCallback4(async () => {
+    if (!workflow) return;
+    const confirmed = confirmPlan(workflow);
+    try {
+      upsertWorkflow(db, confirmed);
+    } catch (err) {
+      logger.error({ err }, "Failed to persist workflow");
+    }
+    const controller = new AbortController();
+    abortRef.current = controller;
+    abortMapRef.current.set(confirmed.id, controller);
+    setIsExecuting(true);
+    if (plannerSessionRef.current) {
+      plannerSessionRef.current = null;
+    }
+    dispatch({ type: "SHOW_EXECUTION", workflow: confirmed });
+    try {
+      const result = await executeWorkflow({
+        workflow: confirmed,
+        triggerData: null,
+        db,
+        cwd,
+        signal: controller.signal,
+        onProgress: (stepId, msg) => {
+          if (typeof msg === "object" && msg !== null && "status" in msg) {
+            dispatch({ type: "UPDATE_STEP", stepId, progress: { stepId, status: msg.status } });
+          } else {
+            dispatch({ type: "UPDATE_STEP", stepId, progress: { stepId, status: "running" } });
+            if (typeof msg === "string") {
+              dispatch({ type: "ADD_OUTPUT", line: msg });
+            }
+          }
+        }
+      });
+      for (const [stepId, stepResult] of result.results) {
+        dispatch({ type: "UPDATE_STEP", stepId, progress: { stepId, status: stepResult.status } });
+      }
+      if (result.status === "failed") {
+        const failedSteps = [...result.results.entries()].filter(([, r]) => r.status === "failed" && r.error).map(([id, r]) => `${id}: ${r.error}`);
+        const errorDetail = failedSteps.length > 0 ? `
+${failedSteps.join("\n")}` : "";
+        dispatch({ type: "ADD_MESSAGE", message: { type: "error", text: `Workflow execution failed.${errorDetail}` } });
+      } else {
+        const trigger = confirmed.trigger;
+        if (trigger.type === "poll") {
+          dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: `Workflow completed first run. It will run every ${trigger.interval_seconds}s.` } });
+          const bridge = bridgeRef.current;
+          if (bridge?.triggerLoop && !bridge.isExternal) {
+            bridge.triggerLoop.registerTrigger(confirmed);
+          }
+        } else if (trigger.type === "cron") {
+          dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: `Workflow completed first run. Scheduled: ${trigger.expression}` } });
+          const bridge = bridgeRef.current;
+          if (bridge?.triggerLoop && !bridge.isExternal) {
+            bridge.triggerLoop.registerTrigger(confirmed);
+          }
+        } else {
+          dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: "Workflow execution completed." } });
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      dispatch({ type: "ADD_MESSAGE", message: { type: "error", text: `Execution failed: ${msg}` } });
+      logger.error({ err }, "Workflow execution failed");
+    } finally {
+      abortMapRef.current.delete(confirmed.id);
+      setIsExecuting(abortMapRef.current.size > 0);
+    }
+  }, [workflow, db, cwd]);
+  const handleExecutionAbort = useCallback4(() => {
+    abortRef.current?.abort();
+  }, []);
+  const handleModify = useCallback4(() => {
+    dispatch({ type: "SHOW_CHAT" });
+    dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: "Describe your modifications:" } });
+  }, []);
+  const handleCancel = useCallback4(() => {
+    if (workflow) {
+      const rejected = rejectPlan(workflow);
+      updateWorkflowPhase(db, workflow.id, rejected.phase);
+    }
+    if (plannerSessionRef.current) {
+      plannerSessionRef.current = null;
+    }
+    dispatch({ type: "SHOW_CHAT" });
+    dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: "Plan cancelled." } });
+  }, [workflow, db]);
+  const handleExecutionBack = useCallback4(() => {
+    dispatch({ type: "SHOW_CHAT" });
+  }, []);
+  return {
+    isExecuting,
+    abortMapRef,
+    handleConfirm,
+    handleModify,
+    handleCancel,
+    handleExecutionAbort,
+    handleExecutionBack
+  };
+}
+
+// src/tui/hooks/use-global-keypress.ts
+import React3, { useCallback as useCallback5 } from "react";
+
+// src/tui/key-bindings.ts
+var keyBindings = {
+  ctrlC: ((input, key) => input === "c" && key.ctrl),
+  ctrlD: ((input, key) => input === "d" && key.ctrl),
+  escape: ((_input, key) => key.escape),
+  submit: ((_input, key) => key.return),
+  scrollUp: ((input, key) => key.ctrl && input === "p"),
+  scrollDown: ((input, key) => key.ctrl && input === "n"),
+  confirmPlan: ((input) => input.toLowerCase() === "y"),
+  modifyPlan: ((input) => input.toLowerCase() === "m"),
+  cancelPlan: ((input) => input.toLowerCase() === "n"),
+  abortExec: ((input) => input === "x"),
+  quit: ((input) => input === "q"),
+  upArrow: ((_input, key) => key.upArrow),
+  downArrow: ((_input, key) => key.downArrow),
+  stopWorkflow: ((input) => input === "s"),
+  deleteWorkflow: ((input) => input === "x"),
+  confirmYes: ((input) => input.toLowerCase() === "y"),
+  confirmNo: ((input, key) => input.toLowerCase() === "n" || key.escape)
+};
+
+// src/tui/hooks/exit-helpers.ts
+var sessionStartTime = null;
+function markSessionStart() {
+  sessionStartTime = Date.now();
+}
+function formatDuration(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+function printFarewell() {
+  if (sessionStartTime !== null) {
+    const duration = formatDuration(Date.now() - sessionStartTime);
+    process.stdout.write(`
+Goodbye! Session: ${duration}
+`);
+  }
+}
+function stopBridgeAndExit(bridgeRef, exit) {
+  const bridge = bridgeRef.current;
+  if (bridge && !bridge.isExternal) {
+    stopDaemonBridge(bridge).finally(() => {
+      printFarewell();
+      exit();
+      process.exit(0);
+    });
+  } else {
+    printFarewell();
+    exit();
+    process.exit(0);
+  }
+}
+function handleExit(options) {
+  const { bridgeRef, exit, showDialog, dismissDialog, isExecuting } = options;
+  const daemonRunning = isDaemonRunning();
+  if (daemonRunning) {
+    showDialog({
+      title: "Exit CueClaw",
+      message: isExecuting ? "A workflow is running and will be cancelled. A background daemon is also running." : "A background daemon is running with your bot channels.",
+      actions: [
+        { key: "k", label: "Keep daemon running", handler: () => {
+          dismissDialog();
+          stopBridgeAndExit(bridgeRef, exit);
+        } },
+        { key: "s", label: "Stop daemon & exit", handler: () => {
+          dismissDialog();
+          stopExternalDaemon();
+          stopBridgeAndExit(bridgeRef, exit);
+        } }
+      ]
+    });
+  } else {
+    stopBridgeAndExit(bridgeRef, exit);
+  }
+}
+
+// src/tui/renderers.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function phaseColor(phase) {
+  switch (phase) {
+    case "executing":
+      return "yellow";
+    case "active":
+      return "green";
+    case "completed":
+      return "green";
+    case "failed":
+      return "red";
+    case "paused":
+      return "gray";
+    default:
+      return "white";
+  }
+}
+function WorkflowTable({ workflows }) {
+  if (workflows.length === 0) {
+    return /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: "No workflows found." });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx3(Box2, { width: 14, children: /* @__PURE__ */ jsx3(Text2, { bold: true, dimColor: true, children: "ID" }) }),
+      /* @__PURE__ */ jsx3(Box2, { width: 28, children: /* @__PURE__ */ jsx3(Text2, { bold: true, dimColor: true, children: "Name" }) }),
+      /* @__PURE__ */ jsx3(Box2, { width: 14, children: /* @__PURE__ */ jsx3(Text2, { bold: true, dimColor: true, children: "Phase" }) }),
+      /* @__PURE__ */ jsx3(Box2, { width: 16, children: /* @__PURE__ */ jsx3(Text2, { bold: true, dimColor: true, children: "Trigger" }) })
+    ] }),
+    workflows.map((wf) => {
+      const trigger = wf.trigger.type === "poll" ? `poll (${wf.trigger.interval_seconds}s)` : wf.trigger.type === "cron" ? `cron` : "manual";
+      return /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx3(Box2, { width: 14, children: /* @__PURE__ */ jsx3(Text2, { children: wf.id.slice(0, 12) }) }),
+        /* @__PURE__ */ jsx3(Box2, { width: 28, children: /* @__PURE__ */ jsx3(Text2, { children: wf.name.slice(0, 26) }) }),
+        /* @__PURE__ */ jsx3(Box2, { width: 14, children: /* @__PURE__ */ jsx3(Text2, { color: phaseColor(wf.phase), children: wf.phase }) }),
+        /* @__PURE__ */ jsx3(Box2, { width: 16, children: /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: trigger }) })
+      ] }, wf.id);
+    }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "\n",
+      "Use /status ",
+      "<id>",
+      " to view details, /pause /resume /delete to manage."
+    ] })
+  ] });
+}
+function WorkflowDetail({ workflow, latestRun, stepRuns }) {
+  const trigger = workflow.trigger.type === "poll" ? `poll (${workflow.trigger.interval_seconds}s)` : workflow.trigger.type === "cron" ? `cron (${workflow.trigger.expression})` : "manual";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text2, { bold: true, children: workflow.name }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "ID: ",
+      workflow.id
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "Phase: ",
+      /* @__PURE__ */ jsx3(Text2, { color: phaseColor(workflow.phase), children: workflow.phase })
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "Trigger: ",
+      trigger
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "Created: ",
+      workflow.created_at
+    ] }),
+    /* @__PURE__ */ jsx3(Text2, { children: "" }),
+    /* @__PURE__ */ jsx3(Text2, { bold: true, children: "Steps:" }),
+    workflow.steps.map((step, i) => {
+      const deps = step.depends_on.length > 0 ? ` (after: ${step.depends_on.join(", ")})` : "";
+      return /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "  ",
+        i + 1,
+        ". ",
+        step.id,
+        ": ",
+        step.description.slice(0, 60),
+        deps
+      ] }, step.id);
+    }),
+    latestRun && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx3(Text2, { children: "" }),
+      /* @__PURE__ */ jsx3(Text2, { bold: true, children: "Latest Run:" }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "  Status: ",
+        latestRun.status
+      ] }),
+      latestRun.error && /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+        "  Error: ",
+        latestRun.error
+      ] }),
+      stepRuns && stepRuns.length > 0 && /* @__PURE__ */ jsxs2(Fragment, { children: [
+        /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: "  Step results:" }),
+        stepRuns.map((sr) => /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          "    ",
+          sr.step_id,
+          ": ",
+          sr.status,
+          sr.output_json ? ` \u2014 ${sr.output_json.slice(0, 50)}` : ""
+        ] }, sr.id))
+      ] })
+    ] })
+  ] });
+}
+
+// src/tui/hooks/use-global-keypress.ts
+function useGlobalKeypress({
+  isExecuting,
+  bridgeRef,
+  abortMapRef,
+  db,
+  view,
+  exit,
+  showDialog,
+  dismissDialog,
+  dispatch
+}) {
+  useKeypress("global-ctrl-c", KeyPriority.High, useCallback5((input, key) => {
+    if (keyBindings.ctrlC(input, key)) {
+      for (const controller of abortMapRef.current.values()) {
+        controller.abort();
+      }
+      handleExit({ bridgeRef, exit, showDialog, dismissDialog, isExecuting });
+      return true;
+    }
+    return false;
+  }, [isExecuting, exit, showDialog, dismissDialog]));
+  useKeypress("global-ctrl-d", KeyPriority.Normal, useCallback5((input, key) => {
+    if (keyBindings.ctrlD(input, key)) {
+      const workflows = listWorkflows(db);
+      dispatch({
+        type: "ADD_MESSAGE",
+        message: {
+          type: "assistant-jsx",
+          content: React3.createElement(WorkflowTable, { workflows })
+        }
+      });
+      return true;
+    }
+    return false;
+  }, [db]), view !== "onboarding");
+}
+
+// src/tui/hooks/use-command-dispatch.ts
+import React4, { useCallback as useCallback6, useMemo } from "react";
+
+// src/tui/commands/registry.ts
+var commands = [];
+function registerCommand(cmd) {
+  commands.push(cmd);
+}
+function getCommands() {
+  return commands;
+}
+function findCommand(name) {
+  const lower = name.toLowerCase();
+  return commands.find((c) => c.name === lower || c.aliases.includes(lower));
+}
+function parseSlashCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx === -1) {
+    return { name: trimmed.slice(1), args: "" };
+  }
+  return { name: trimmed.slice(1, spaceIdx), args: trimmed.slice(spaceIdx + 1).trim() };
+}
+
+// src/tui/commands/help.ts
+registerCommand({
+  name: "help",
+  aliases: ["h", "?"],
+  description: "Show available commands",
+  usage: "/help",
+  execute(_args, ctx) {
+    const commands2 = getCommands();
+    const lines = commands2.map((c) => {
+      const aliases = c.aliases.length > 0 ? ` (${c.aliases.map((a) => "/" + a).join(", ")})` : "";
+      return `  /${c.name}${aliases} \u2014 ${c.description}`;
+    });
+    ctx.addMessage({ type: "assistant", text: "Available commands:\n" + lines.join("\n") });
+  }
+});
+
+// src/tui/commands/list.ts
+registerCommand({
+  name: "list",
+  aliases: ["ls"],
+  description: "List all workflows",
+  usage: "/list",
+  // Handled in use-command-dispatch.ts
+  execute() {
+  }
+});
+
+// src/tui/commands/status.ts
+registerCommand({
+  name: "status",
+  aliases: ["st"],
+  description: "View workflow status",
+  usage: "/status [id]",
+  // Handled in use-command-dispatch.ts
+  execute() {
+  }
+});
+
+// src/tui/commands/pause.ts
+registerCommand({
+  name: "pause",
+  aliases: [],
+  description: "Pause a workflow",
+  usage: "/pause <id>",
+  execute(args, ctx) {
+    if (!args) {
+      ctx.addMessage({ type: "assistant", text: "Usage: /pause <workflow-id>" });
+      return;
+    }
+    const wf = getWorkflow(ctx.db, args) ?? listWorkflows(ctx.db).find((w) => w.id.startsWith(args));
+    if (!wf) {
+      ctx.addMessage({ type: "assistant", text: `Workflow not found: ${args}` });
+      return;
+    }
+    if (wf.phase !== "active") {
+      ctx.addMessage({ type: "assistant", text: `Cannot pause workflow in phase "${wf.phase}" (must be "active")` });
+      return;
+    }
+    updateWorkflowPhase(ctx.db, wf.id, "paused");
+    ctx.addMessage({ type: "assistant", text: `Paused workflow "${wf.name}" (${wf.id})` });
+  }
+});
+
+// src/tui/commands/resume.ts
+registerCommand({
+  name: "resume",
+  aliases: [],
+  description: "Resume a paused workflow",
+  usage: "/resume <id>",
+  execute(args, ctx) {
+    if (!args) {
+      ctx.addMessage({ type: "assistant", text: "Usage: /resume <workflow-id>" });
+      return;
+    }
+    const wf = getWorkflow(ctx.db, args) ?? listWorkflows(ctx.db).find((w) => w.id.startsWith(args));
+    if (!wf) {
+      ctx.addMessage({ type: "assistant", text: `Workflow not found: ${args}` });
+      return;
+    }
+    if (wf.phase !== "paused") {
+      ctx.addMessage({ type: "assistant", text: `Cannot resume workflow in phase "${wf.phase}" (must be "paused")` });
+      return;
+    }
+    const nextPhase = wf.trigger.type === "manual" ? "executing" : "active";
+    updateWorkflowPhase(ctx.db, wf.id, nextPhase);
+    ctx.addMessage({ type: "assistant", text: `Resumed workflow "${wf.name}" \u2014 phase: ${nextPhase}` });
+  }
+});
+
+// src/tui/commands/delete.ts
+registerCommand({
+  name: "delete",
+  aliases: ["rm"],
+  description: "Delete a workflow",
+  usage: "/delete <id>",
+  execute(args, ctx) {
+    if (!args) {
+      ctx.addMessage({ type: "assistant", text: "Usage: /delete <workflow-id>" });
+      return;
+    }
+    const wf = getWorkflow(ctx.db, args) ?? listWorkflows(ctx.db).find((w) => w.id.startsWith(args));
+    if (!wf) {
+      ctx.addMessage({ type: "assistant", text: `Workflow not found: ${args}` });
+      return;
+    }
+    if (wf.phase === "executing") {
+      ctx.addMessage({ type: "assistant", text: "Cannot delete workflow while it is executing." });
+      return;
+    }
+    deleteWorkflow(ctx.db, wf.id);
+    ctx.addMessage({ type: "assistant", text: `Deleted workflow "${wf.name}" (${wf.id})` });
+  }
+});
+
+// src/tui/commands/config.ts
+registerCommand({
+  name: "config",
+  aliases: ["cfg"],
+  description: "View or set configuration",
+  usage: "/config get [key] | /config set <key> <value>",
+  execute(args, ctx) {
+    const parts = args.split(/\s+/);
+    const subcommand = parts[0]?.toLowerCase();
+    if (!subcommand || subcommand === "get") {
+      const key = parts[1];
+      try {
+        const config = loadConfig();
+        if (!key) {
+          ctx.addMessage({ type: "assistant", text: "Configuration:\n" + JSON.stringify(config, null, 2) });
+          return;
+        }
+        const keyParts = key.split(".");
+        let value = config;
+        for (const p of keyParts) {
+          if (value === null || value === void 0) break;
+          value = value[p];
+        }
+        ctx.addMessage({ type: "assistant", text: value !== void 0 ? `${key} = ${JSON.stringify(value, null, 2)}` : `Key not found: ${key}` });
+      } catch (err) {
+        ctx.addMessage({ type: "error", text: `Error loading config: ${err instanceof Error ? err.message : String(err)}` });
+      }
+      return;
+    }
+    if (subcommand === "set") {
+      const key = parts[1];
+      const value = parts.slice(2).join(" ");
+      if (!key || !value) {
+        ctx.addMessage({ type: "assistant", text: "Usage: /config set <key> <value>" });
+        return;
+      }
+      try {
+        let parsed = value;
+        if (value === "true") parsed = true;
+        else if (value === "false") parsed = false;
+        else if (/^\d+$/.test(value)) parsed = Number(value);
+        const keyParts = key.split(".");
+        const update = {};
+        let target = update;
+        for (let i = 0; i < keyParts.length - 1; i++) {
+          target[keyParts[i]] = {};
+          target = target[keyParts[i]];
+        }
+        target[keyParts[keyParts.length - 1]] = parsed;
+        writeConfig(update);
+        const newConfig = loadConfig();
+        ctx.setConfig(newConfig);
+        ctx.addMessage({ type: "assistant", text: `Set ${key} = ${JSON.stringify(parsed)}` });
+      } catch (err) {
+        ctx.addMessage({ type: "error", text: `Error setting config: ${err instanceof Error ? err.message : String(err)}` });
+      }
+      return;
+    }
+    ctx.addMessage({ type: "assistant", text: "Usage: /config get [key] | /config set <key> <value>" });
+  }
+});
+
+// src/tui/commands/daemon.ts
+registerCommand({
+  name: "daemon",
+  aliases: [],
+  description: "View daemon status",
+  usage: "/daemon status|start|stop",
+  execute(args, ctx) {
+    const subcommand = args.trim().toLowerCase() || "status";
+    if (subcommand === "status") {
+      const status = getServiceStatus();
+      const bridgeStatus = ctx.bridge ? ctx.bridge.isExternal ? "external service" : "in-process" : "not connected";
+      ctx.addMessage({ type: "assistant", text: `Daemon status: ${status}
+Bridge: ${bridgeStatus}` });
+      return;
+    }
+    if (subcommand === "start" || subcommand === "stop") {
+      ctx.addMessage({ type: "assistant", text: `Use the CLI for daemon ${subcommand}: cueclaw daemon ${subcommand}` });
+      return;
+    }
+    ctx.addMessage({ type: "assistant", text: "Usage: /daemon status|start|stop" });
+  }
+});
+
+// src/tui/version.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../package.json");
+var isDev2 = !fileURLToPath(import.meta.url).includes("/dist/");
+var appVersion = isDev2 ? "dev" : pkg.version;
+
+// src/tui/commands/info.ts
+registerCommand({
+  name: "info",
+  aliases: [],
+  description: "Show system information",
+  usage: "/info",
+  execute(_args, ctx) {
+    const config = ctx.config;
+    const lines = [
+      `CueClaw ${appVersion === "dev" ? "dev" : `v${appVersion}`}`,
+      `Working directory: ${ctx.cwd}`,
+      `Config directory: ${cueclawHome()}`,
+      ""
+    ];
+    if (config) {
+      lines.push(`Planner model: ${config.claude.planner.model}`);
+      lines.push(`Executor model: ${config.claude.executor.model}`);
+      lines.push(`Base URL: ${config.claude.base_url}`);
+      if (config.telegram?.enabled) lines.push("Telegram: enabled");
+      if (config.whatsapp?.enabled) lines.push("WhatsApp: enabled");
+      if (config.container?.enabled) lines.push("Container isolation: enabled");
+    }
+    ctx.addMessage({ type: "assistant", text: lines.join("\n") });
+  }
+});
+
+// src/tui/commands/clear.ts
+registerCommand({
+  name: "clear",
+  aliases: ["cls"],
+  description: "Clear chat messages",
+  usage: "/clear",
+  // Handled in use-command-dispatch.ts
+  execute() {
+  }
+});
+
+// src/tui/commands/new.ts
+registerCommand({
+  name: "new",
+  aliases: [],
+  description: "Generate a plan directly (skip conversation)",
+  usage: "/new <description>",
+  // Handled in use-command-dispatch.ts
+  execute() {
+  }
+});
+
+// src/tui/commands/cancel.ts
+registerCommand({
+  name: "cancel",
+  aliases: [],
+  description: "Cancel current conversation",
+  usage: "/cancel",
+  // Handled in use-command-dispatch.ts
+  execute() {
+  }
+});
+
+// src/tui/commands/bot.ts
+registerCommand({
+  name: "bot",
+  aliases: [],
+  description: "Manage bot channels",
+  usage: "/bot start|status",
+  // Handled in use-command-dispatch.ts
+  execute() {
+  }
+});
+
+// src/tui/commands/setup.ts
+registerCommand({
+  name: "setup",
+  aliases: [],
+  description: "Re-run configuration setup",
+  usage: "/setup",
+  // Handled in use-command-dispatch.ts
+  execute() {
+  }
+});
+
+// src/tui/commands/theme.ts
+registerCommand({
+  name: "theme",
+  aliases: [],
+  description: "Switch color theme",
+  usage: "/theme [dark|light|dracula]",
+  completion: ["dark", "light", "dracula"],
+  execute(args, ctx) {
+    const name = args.trim().toLowerCase();
+    if (!name) {
+      const available = themeManager.getAvailableThemes().join(", ");
+      const current = themeManager.getThemeName();
+      ctx.addMessage({ type: "assistant", text: `Current theme: ${current}
+Available: ${available}` });
+      return;
+    }
+    const success = themeManager.setTheme(name);
+    if (success) {
+      ctx.setThemeVersion((v) => v + 1);
+      ctx.addMessage({ type: "assistant", text: `Switched to ${name} theme.` });
+    } else {
+      const available = themeManager.getAvailableThemes().join(", ");
+      ctx.addMessage({ type: "error", text: `Unknown theme: ${name}. Available: ${available}` });
+    }
+  }
+});
+
+// src/tui/commands/quit.ts
+registerCommand({
+  name: "quit",
+  aliases: ["exit", "q"],
+  description: "Exit CueClaw",
+  usage: "/quit",
+  execute() {
+  }
+});
+
+// src/tui/hooks/use-command-dispatch.ts
+function useCommandDispatch({
+  config,
+  db,
+  cwd,
+  bridgeRef,
+  plannerSessionRef,
+  dispatch,
+  setConfig,
+  setThemeVersion,
+  exit,
+  showDialog,
+  dismissDialog
+}) {
+  const commandCtx = useMemo(() => ({
+    db,
+    config,
+    cwd,
+    bridge: bridgeRef.current,
+    addMessage: (msg) => dispatch({ type: "ADD_MESSAGE", message: msg }),
+    clearMessages: () => dispatch({ type: "SET_MESSAGES", messages: [] }),
+    setConfig,
+    setThemeVersion
+  }), [db, config, cwd]);
+  const handleSlashCommand = useCallback6(async (text) => {
+    if (!config) return false;
+    const parsed = parseSlashCommand(text);
+    if (!parsed) return false;
+    commandCtx.bridge = bridgeRef.current;
+    commandCtx.config = config;
+    dispatch({ type: "ADD_MESSAGE", message: { type: "user", text } });
+    if (parsed.name === "cancel") {
+      if (plannerSessionRef.current) {
+        cancelPlannerSession(plannerSessionRef.current);
+        plannerSessionRef.current = null;
+      }
+      dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: "Conversation cancelled." } });
+      return true;
+    }
+    if (parsed.name === "new" && !parsed.args) {
+      dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: "Usage: /new <workflow description>" } });
+      return true;
+    }
+    if (parsed.name === "new" && parsed.args) {
+      plannerSessionRef.current = null;
+      dispatch({ type: "SET_GENERATING", value: true });
+      dispatch({ type: "SET_STREAMING_TEXT", text: "" });
+      try {
+        const { generatePlan } = await import("./planner-MJ3XBCWH.js");
+        const workflow = await generatePlan(parsed.args, config, { channel: "tui" });
+        dispatch({ type: "ADD_MESSAGE", message: { type: "plan-ready", workflowName: workflow.name } });
+        dispatch({ type: "SET_GENERATING", value: false });
+        dispatch({ type: "SHOW_PLAN", workflow });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        dispatch({ type: "ADD_MESSAGE", message: { type: "error", text: `Error: ${msg}` } });
+        dispatch({ type: "SET_GENERATING", value: false });
+      }
+      return true;
+    }
+    if (parsed.name === "list" || parsed.name === "ls" || (parsed.name === "status" || parsed.name === "st") && !parsed.args) {
+      const workflows = listWorkflows(db);
+      dispatch({ type: "SHOW_STATUS", workflows });
+      return true;
+    }
+    if ((parsed.name === "status" || parsed.name === "st") && parsed.args) {
+      const wf = getWorkflow(db, parsed.args) ?? listWorkflows(db).find((w) => w.id.startsWith(parsed.args));
+      if (wf) {
+        const runs = getWorkflowRunsByWorkflowId(db, wf.id);
+        const latestRun = runs[0];
+        const stepRuns = latestRun ? getStepRunsByRunId(db, latestRun.id) : void 0;
+        dispatch({
+          type: "ADD_MESSAGE",
+          message: {
+            type: "assistant-jsx",
+            content: React4.createElement(WorkflowDetail, { workflow: wf, latestRun, stepRuns })
+          }
+        });
+        return true;
+      }
+      dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: `Workflow not found: ${parsed.args}` } });
+      return true;
+    }
+    if (parsed.name === "clear" || parsed.name === "cls") {
+      dispatch({ type: "SET_MESSAGES", messages: [] });
+      return true;
+    }
+    if (parsed.name === "bot" && parsed.args.trim().toLowerCase() === "start") {
+      const bridge = bridgeRef.current;
+      if (bridge && config) {
+        dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: "Starting bot channels..." } });
+        try {
+          await startBotChannels(bridge, config);
+          dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: "Bot channels started." } });
+        } catch (err) {
+          dispatch({ type: "ADD_MESSAGE", message: { type: "error", text: `Failed to start bots: ${err instanceof Error ? err.message : String(err)}` } });
+        }
+      } else {
+        dispatch({ type: "ADD_MESSAGE", message: { type: "error", text: "Daemon not running. Cannot start bots." } });
+      }
+      return true;
+    }
+    if (parsed.name === "setup") {
+      dispatch({ type: "SET_MESSAGES", messages: [] });
+      dispatch({ type: "SHOW_ONBOARDING" });
+      return true;
+    }
+    if (parsed.name === "quit" || parsed.name === "exit" || parsed.name === "q") {
+      handleExit({ bridgeRef, exit, showDialog, dismissDialog });
+      return true;
+    }
+    const cmd = findCommand(parsed.name);
+    if (cmd) {
+      await cmd.execute(parsed.args, commandCtx);
+    } else {
+      dispatch({ type: "ADD_MESSAGE", message: { type: "assistant", text: `Unknown command: /${parsed.name}. Type /help for available commands.` } });
+    }
+    return true;
+  }, [config, db, commandCtx]);
+  return { handleSlashCommand, commandCtx };
+}
+
+// src/tui/app-provider.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function appReducer(state, action) {
+  switch (action.type) {
+    case "SHOW_CHAT":
+      return { ...state, view: "chat", isGenerating: false, streamingText: "" };
+    case "SHOW_ONBOARDING":
+      return { ...state, view: "onboarding", isGenerating: false, streamingText: "" };
+    case "SHOW_PLAN":
+      return { ...state, view: "plan", workflow: action.workflow, isGenerating: false, streamingText: "" };
+    case "SHOW_EXECUTION":
+      return { ...state, view: "execution", previousView: state.view, workflow: action.workflow, stepProgress: /* @__PURE__ */ new Map(), executionOutput: [], isGenerating: false, streamingText: "" };
+    case "SHOW_STATUS":
+      return { ...state, view: "status", statusWorkflows: action.workflows, isGenerating: false, streamingText: "" };
+    case "SHOW_DETAIL":
+      return { ...state, view: "detail", previousView: state.view, workflow: action.workflow, detailRuns: action.runs, detailStepRuns: action.stepRuns, isGenerating: false, streamingText: "" };
+    case "ADD_MESSAGE":
+      return { ...state, messages: [...state.messages, action.message] };
+    case "SET_MESSAGES":
+      return { ...state, messages: action.messages };
+    case "SET_GENERATING":
+      return { ...state, isGenerating: action.value };
+    case "SET_STREAMING_TEXT":
+      return { ...state, streamingText: action.text };
+    case "UPDATE_STEP":
+      return { ...state, stepProgress: new Map(state.stepProgress).set(action.stepId, action.progress) };
+    case "ADD_OUTPUT":
+      return { ...state, executionOutput: [...state.executionOutput, action.line] };
+    default:
+      return state;
+  }
+}
+function AppProvider({ cwd, skipOnboarding, children }) {
+  const { exit } = useApp();
+  const { showDialog, dismissDialog } = useDialog();
+  const validation = useMemo2(() => validateConfig(), []);
+  const needsSetup = !skipOnboarding && !validation.valid;
+  const [config, setConfig] = useState4(() => {
+    if (needsSetup) return null;
+    try {
+      return loadConfig();
+    } catch {
+      return null;
+    }
+  });
+  const db = useMemo2(() => initDb(), []);
+  const [themeVersion, setThemeVersion] = useState4(0);
+  const initialState = {
+    view: needsSetup ? "onboarding" : "chat",
+    previousView: null,
+    messages: [],
+    workflow: null,
+    isGenerating: false,
+    stepProgress: /* @__PURE__ */ new Map(),
+    executionOutput: [],
+    streamingText: "",
+    statusWorkflows: [],
+    detailRuns: [],
+    detailStepRuns: []
+  };
+  const [state, dispatch] = useReducer(appReducer, initialState);
+  useEffect3(() => {
+    markSessionStart();
+  }, []);
+  useEffect3(() => {
+    return onLogLine((line) => {
+      dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: line } });
+    });
+  }, []);
+  const { bridgeRef, daemonStatus } = useDaemonBridge(config, db, cwd, dispatch);
+  const planner = usePlannerSession(config, dispatch, state.streamingText);
+  const execution = useWorkflowExecution(
+    state.workflow,
+    db,
+    cwd,
+    bridgeRef,
+    planner.plannerSessionRef,
+    dispatch
+  );
+  const { handleSlashCommand } = useCommandDispatch({
+    config,
+    db,
+    cwd,
+    bridgeRef,
+    plannerSessionRef: planner.plannerSessionRef,
+    dispatch,
+    setConfig,
+    setThemeVersion,
+    exit,
+    showDialog,
+    dismissDialog
+  });
+  useGlobalKeypress({
+    isExecuting: execution.isExecuting,
+    bridgeRef,
+    abortMapRef: execution.abortMapRef,
+    db,
+    view: state.view,
+    exit,
+    showDialog,
+    dismissDialog,
+    dispatch
+  });
+  const handleOnboardingComplete = useCallback7((newConfig) => {
+    setConfig(newConfig);
+    dispatch({ type: "SHOW_CHAT" });
+  }, []);
+  const handleOnboardingCancel = useCallback7(() => {
+    try {
+      setConfig(loadConfig());
+    } catch {
+    }
+    dispatch({ type: "SHOW_CHAT" });
+  }, []);
+  const handleStatusBack = useCallback7(() => {
+    dispatch({ type: "SHOW_CHAT" });
+  }, []);
+  const handleStatusSelect = useCallback7((workflow) => {
+    const runs = getWorkflowRunsByWorkflowId(db, workflow.id);
+    const latestRun = runs[0];
+    const stepRuns = latestRun ? getStepRunsByRunId(db, latestRun.id) : [];
+    dispatch({ type: "SHOW_DETAIL", workflow, runs, stepRuns });
+  }, [db]);
+  const handleStatusStop = useCallback7((workflow) => {
+    const controller = execution.abortMapRef.current.get(workflow.id);
+    if (controller) {
+      controller.abort();
+      dispatch({ type: "ADD_MESSAGE", message: { type: "system", text: `Stopping workflow: ${workflow.name}` } });
+    } else {
+      dispatch({ type: "ADD_MESSAGE", message: { type: "warning", text: `Workflow "${workflow.name}" is not currently executing.` } });
+    }
+    const workflows = listWorkflows(db);
+    dispatch({ type: "SHOW_STATUS", workflows });
+  }, [db, execution.abortMapRef]);
+  const handleStatusDelete = useCallback7((workflow) => {
+    deleteWorkflow(db, workflow.id);
+    const updated = listWorkflows(db);
+    dispatch({ type: "SHOW_STATUS", workflows: updated });
+  }, [db]);
+  const handleDetailBack = useCallback7(() => {
+    const workflows = listWorkflows(db);
+    dispatch({ type: "SHOW_STATUS", workflows });
+  }, [db]);
+  const handleDetailSelectRun = useCallback7((runId) => {
+    if (!state.workflow) return;
+    dispatch({ type: "SHOW_EXECUTION", workflow: state.workflow });
+    const stepRuns = getStepRunsByRunId(db, runId);
+    for (const sr of stepRuns) {
+      dispatch({
+        type: "UPDATE_STEP",
+        stepId: sr.step_id,
+        progress: {
+          stepId: sr.step_id,
+          status: sr.status,
+          duration: sr.duration_ms ?? void 0
+        }
+      });
+    }
+  }, [db, state.workflow]);
+  const handleChatSubmit = useCallback7(async (text) => {
+    if (!config) return;
+    const wasCommand = await handleSlashCommand(text);
+    if (!wasCommand) {
+      await planner.handleUserMessage(text);
+    }
+  }, [config, handleSlashCommand, planner.handleUserMessage]);
+  const footerExtra = daemonStatus === "external" ? " | Background service detected" : daemonStatus === "running" ? " | Daemon active" : "";
+  const footerHints = planner.isConversing ? "Enter send \xB7 /cancel abort \xB7 /help commands" : void 0;
+  const handleExecutionBackWithNav = useCallback7(() => {
+    if (state.previousView === "detail" && state.workflow) {
+      const runs = getWorkflowRunsByWorkflowId(db, state.workflow.id);
+      const latestRun = runs[0];
+      const stepRuns = latestRun ? getStepRunsByRunId(db, latestRun.id) : [];
+      dispatch({ type: "SHOW_DETAIL", workflow: state.workflow, runs, stepRuns });
+    } else if (state.previousView === "status") {
+      const workflows = listWorkflows(db);
+      dispatch({ type: "SHOW_STATUS", workflows });
+    } else {
+      execution.handleExecutionBack();
+    }
+  }, [state.previousView, state.workflow, db, execution.handleExecutionBack]);
+  const uiState = useMemo2(() => ({
+    view: state.view,
+    messages: state.messages,
+    workflow: state.workflow,
+    isGenerating: state.isGenerating,
+    stepProgress: state.stepProgress,
+    executionOutput: state.executionOutput,
+    streamingText: state.streamingText,
+    daemonStatus,
+    isExecuting: execution.isExecuting,
+    config,
+    cwd,
+    footerExtra,
+    footerHints,
+    isConversing: planner.isConversing,
+    themeVersion,
+    statusWorkflows: state.statusWorkflows,
+    detailRuns: state.detailRuns,
+    detailStepRuns: state.detailStepRuns
+  }), [state, daemonStatus, execution.isExecuting, config, cwd, footerExtra, footerHints, planner.isConversing, themeVersion]);
+  const uiActions = useMemo2(() => ({
+    handleChatSubmit,
+    handleCancelGeneration: planner.handleCancelGeneration,
+    handleConfirm: execution.handleConfirm,
+    handleModify: execution.handleModify,
+    handleCancel: execution.handleCancel,
+    handleExecutionAbort: execution.handleExecutionAbort,
+    handleExecutionBack: handleExecutionBackWithNav,
+    handleOnboardingComplete,
+    handleOnboardingCancel,
+    handleStatusBack,
+    handleStatusSelect,
+    handleStatusStop,
+    handleStatusDelete,
+    handleDetailBack,
+    handleDetailSelectRun
+  }), [handleChatSubmit, planner.handleCancelGeneration, execution.handleConfirm, execution.handleModify, execution.handleCancel, execution.handleExecutionAbort, handleExecutionBackWithNav, handleOnboardingComplete, handleOnboardingCancel, handleStatusBack, handleStatusSelect, handleStatusStop, handleStatusDelete, handleDetailBack, handleDetailSelectRun]);
+  return /* @__PURE__ */ jsx4(UIStateContext.Provider, { value: uiState, children: /* @__PURE__ */ jsx4(UIActionsContext.Provider, { value: uiActions, children }) });
+}
+
+// src/tui/app-layout.tsx
+import { useMemo as useMemo6 } from "react";
+import { Box as Box21, Static, useStdout as useStdout5 } from "ink";
+
+// src/tui/banner.tsx
+import { memo } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var LOGO = ` \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557      \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557    \u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551    \u2588\u2588\u2551
+\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551
+\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551
+\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D
+ \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D `;
+var Banner = memo(function Banner2({ version: version2, cwd, terminalWidth }) {
+  const displayPath = cwd.replace(/^\/Users\/[^/]+/, "~");
+  const gradient = theme.ui.gradient;
+  if (terminalWidth < 64) {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+      /* @__PURE__ */ jsx5(GradientText, { text: "CueClaw", colors: gradient, bold: true }),
+      /* @__PURE__ */ jsxs3(Text3, { color: theme.ui.comment, children: [
+        version2,
+        " \xB7 ",
+        displayPath
+      ] })
+    ] });
+  }
+  const lines = LOGO.split("\n");
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, paddingTop: 1, children: [
+    lines.map((line, i) => {
+      const t = lines.length > 1 ? i / (lines.length - 1) : 0;
+      const color = lerpGradient(gradient, t);
+      return /* @__PURE__ */ jsx5(Text3, { color, children: line }, i);
+    }),
+    /* @__PURE__ */ jsxs3(Text3, { color: theme.ui.comment, children: [
+      " ",
+      version2,
+      " \xB7 ",
+      displayPath
+    ] }),
+    /* @__PURE__ */ jsx5(Text3, { children: "" })
+  ] });
+});
+function GradientText({ text, colors: gradientColors, bold }) {
+  if (gradientColors.length === 0) return /* @__PURE__ */ jsx5(Text3, { bold, children: text });
+  const chars = [...text];
+  return /* @__PURE__ */ jsx5(Text3, { bold, children: chars.map((ch, i) => {
+    const t = chars.length > 1 ? i / (chars.length - 1) : 0;
+    return /* @__PURE__ */ jsx5(Text3, { color: lerpGradient(gradientColors, t), children: ch }, i);
+  }) });
+}
+function lerpGradient(stops, t) {
+  if (stops.length === 0) return "#ffffff";
+  if (stops.length === 1) return stops[0];
+  const clamped = Math.max(0, Math.min(1, t));
+  const segment = clamped * (stops.length - 1);
+  const idx = Math.floor(segment);
+  const frac = segment - idx;
+  const a = stops[Math.min(idx, stops.length - 1)];
+  const b = stops[Math.min(idx + 1, stops.length - 1)];
+  return interpolateColor(a, b, frac);
+}
+
+// src/tui/chat.tsx
+import { Box as Box15 } from "ink";
+
+// src/tui/main-content.tsx
+import { useState as useState6, useMemo as useMemo3, useEffect as useEffect5, useRef as useRef6, useCallback as useCallback9 } from "react";
+import { Box as Box13, Text as Text13, useStdout as useStdout2 } from "ink";
+
+// src/tui/thinking-indicator.tsx
+import { useState as useState5, useEffect as useEffect4, useCallback as useCallback8, useRef as useRef5, memo as memo2 } from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var DOTS = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var ThinkingIndicator = memo2(function ThinkingIndicator2({ onCancel }) {
+  const [elapsed, setElapsed] = useState5(0);
+  const [frame, setFrame] = useState5(0);
+  const startRef = useRef5(Date.now());
+  useEffect4(() => {
+    const timer = setInterval(() => {
+      setElapsed(Math.floor((Date.now() - startRef.current) / 1e3));
+      setFrame((f) => (f + 1) % DOTS.length);
+    }, 80);
+    return () => clearInterval(timer);
+  }, []);
+  useKeypress("thinking-cancel", KeyPriority.Normal, useCallback8((input, key) => {
+    if (keyBindings.escape(input, key) && onCancel) {
+      onCancel();
+      return true;
+    }
+    return false;
+  }, [onCancel]));
+  const gradient = theme.ui.gradient;
+  const cyclePos = Date.now() / 4e3 % 1;
+  const gradientIdx = Math.floor(cyclePos * gradient.length) % gradient.length;
+  const spinnerColor = gradient[gradientIdx] ?? theme.text.accent;
+  const cancelHint = onCancel ? "  (esc to cancel)" : "";
+  return /* @__PURE__ */ jsxs4(Box4, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx6(Box4, { width: 2, children: /* @__PURE__ */ jsx6(Text4, { color: spinnerColor, children: "\u2726 " }) }),
+    /* @__PURE__ */ jsx6(Text4, { color: spinnerColor, children: DOTS[frame] }),
+    /* @__PURE__ */ jsxs4(Text4, { color: theme.text.secondary, children: [
+      " Thinking... ",
+      elapsed,
+      "s",
+      cancelHint
+    ] })
+  ] });
+});
+
+// src/tui/messages/user-message.tsx
+import { memo as memo3 } from "react";
+import { Box as Box6, Text as Text6, useStdout } from "ink";
+
+// src/tui/half-line-padded-box.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function HalfLinePaddedBox({ backgroundColor, children, width }) {
+  const bg = backgroundColor ?? theme.background.message;
+  const termBg = theme.background.primary;
+  return /* @__PURE__ */ jsxs5(Box5, { width, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Text5, { backgroundColor: bg, color: termBg, children: "\u2580".repeat(width) }),
+    /* @__PURE__ */ jsx7(Box5, { paddingX: 1, flexDirection: "column", children }),
+    /* @__PURE__ */ jsx7(Text5, { color: termBg, backgroundColor: bg, children: "\u2584".repeat(width) })
+  ] });
+}
+
+// src/tui/messages/user-message.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var UserMessage = memo3(function UserMessage2({ text }) {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  return /* @__PURE__ */ jsx8(HalfLinePaddedBox, { width: cols, backgroundColor: theme.background.message, children: /* @__PURE__ */ jsxs6(Box6, { children: [
+    /* @__PURE__ */ jsx8(Box6, { width: 2, children: /* @__PURE__ */ jsx8(Text6, { color: theme.text.accent, children: "> " }) }),
+    /* @__PURE__ */ jsx8(Box6, { flexShrink: 1, children: /* @__PURE__ */ jsx8(Text6, { color: theme.text.secondary, children: text }) })
+  ] }) });
+});
+
+// src/tui/messages/assistant-message.tsx
+import { memo as memo4 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var AssistantMessage = memo4(function AssistantMessage2({ text }) {
+  return /* @__PURE__ */ jsxs7(Box7, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx9(Box7, { width: 2, children: /* @__PURE__ */ jsx9(Text7, { color: theme.text.accent, children: "\u2726 " }) }),
+    /* @__PURE__ */ jsx9(Box7, { flexShrink: 1, children: /* @__PURE__ */ jsx9(Text7, { color: theme.text.primary, children: text }) })
+  ] });
+});
+
+// src/tui/messages/assistant-jsx-message.tsx
+import { memo as memo5 } from "react";
+import { Box as Box8, Text as Text8 } from "ink";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var AssistantJsxMessage = memo5(function AssistantJsxMessage2({ content }) {
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx10(Box8, { children: /* @__PURE__ */ jsx10(Box8, { width: 2, children: /* @__PURE__ */ jsx10(Text8, { color: theme.text.accent, children: "\u2726 " }) }) }),
+    content
+  ] });
+});
+
+// src/tui/messages/system-message.tsx
+import { memo as memo6 } from "react";
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var SystemMessage = memo6(function SystemMessage2({ text }) {
+  return /* @__PURE__ */ jsx11(Box9, { paddingX: 1, paddingLeft: 3, children: /* @__PURE__ */ jsx11(Text9, { color: theme.ui.comment, italic: true, children: text }) });
+});
+
+// src/tui/messages/error-message.tsx
+import { memo as memo7 } from "react";
+import { Box as Box10, Text as Text10 } from "ink";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+var ErrorMessage = memo7(function ErrorMessage2({ text }) {
+  return /* @__PURE__ */ jsxs9(Box10, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Box10, { width: 2, children: /* @__PURE__ */ jsx12(Text10, { color: theme.status.error, children: "\u2717 " }) }),
+    /* @__PURE__ */ jsx12(Box10, { flexShrink: 1, children: /* @__PURE__ */ jsx12(Text10, { color: theme.status.error, children: text }) })
+  ] });
+});
+
+// src/tui/messages/warning-message.tsx
+import { memo as memo8 } from "react";
+import { Box as Box11, Text as Text11 } from "ink";
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+var WarningMessage = memo8(function WarningMessage2({ text }) {
+  return /* @__PURE__ */ jsxs10(Box11, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx13(Box11, { width: 2, children: /* @__PURE__ */ jsx13(Text11, { color: theme.status.warning, children: "\u26A0 " }) }),
+    /* @__PURE__ */ jsx13(Box11, { flexShrink: 1, children: /* @__PURE__ */ jsx13(Text11, { color: theme.status.warning, children: text }) })
+  ] });
+});
+
+// src/tui/messages/plan-ready-message.tsx
+import { memo as memo9 } from "react";
+import { Box as Box12, Text as Text12 } from "ink";
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+var PlanReadyMessage = memo9(function PlanReadyMessage2({ workflowName }) {
+  return /* @__PURE__ */ jsxs11(Box12, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx14(Box12, { width: 2, children: /* @__PURE__ */ jsx14(Text12, { color: theme.status.success, children: "\u2713 " }) }),
+    /* @__PURE__ */ jsx14(Box12, { flexShrink: 1, children: /* @__PURE__ */ jsxs11(Text12, { color: theme.status.success, children: [
+      'Plan ready: "',
+      workflowName,
+      '"'
+    ] }) })
+  ] });
+});
+
+// src/tui/messages/message-display.tsx
+import { jsx as jsx15 } from "react/jsx-runtime";
+function MessageDisplay({ message }) {
+  switch (message.type) {
+    case "user":
+      return /* @__PURE__ */ jsx15(UserMessage, { text: message.text });
+    case "assistant":
+      return /* @__PURE__ */ jsx15(AssistantMessage, { text: message.text });
+    case "assistant-jsx":
+      return /* @__PURE__ */ jsx15(AssistantJsxMessage, { content: message.content });
+    case "system":
+      return /* @__PURE__ */ jsx15(SystemMessage, { text: message.text });
+    case "error":
+      return /* @__PURE__ */ jsx15(ErrorMessage, { text: message.text });
+    case "warning":
+      return /* @__PURE__ */ jsx15(WarningMessage, { text: message.text });
+    case "plan-ready":
+      return /* @__PURE__ */ jsx15(PlanReadyMessage, { workflowName: message.workflowName });
+  }
+}
+
+// src/tui/main-content.tsx
+import { Fragment as Fragment2, jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+function MainContent() {
+  const { messages, isGenerating, streamingText } = useUIState();
+  const { handleCancelGeneration } = useUIActions();
+  const { stdout } = useStdout2();
+  const rows = stdout?.rows ?? 24;
+  const [scrollOffset, setScrollOffset] = useState6(0);
+  const prevMessageCountRef = useRef6(messages.length);
+  useEffect5(() => {
+    if (messages.length > prevMessageCountRef.current && scrollOffset === 0) {
+    }
+    prevMessageCountRef.current = messages.length;
+  }, [messages.length, scrollOffset]);
+  const pageSize = Math.max(1, Math.floor(rows / 2));
+  useKeypress("chat-scroll", KeyPriority.Normal, useCallback9((input, key) => {
+    if (keyBindings.scrollUp(input, key)) {
+      setScrollOffset((prev) => Math.min(prev + pageSize, Math.max(0, messages.length - 1)));
+      return true;
+    }
+    if (keyBindings.scrollDown(input, key)) {
+      setScrollOffset((prev) => Math.max(0, prev - pageSize));
+      return true;
+    }
+    return false;
+  }, [pageSize, messages.length]));
+  const visibleMessages = useMemo3(() => {
+    if (scrollOffset === 0) return messages;
+    const end = messages.length - scrollOffset;
+    return messages.slice(0, Math.max(0, end));
+  }, [messages, scrollOffset]);
+  const hiddenAbove = messages.length - visibleMessages.length;
+  return /* @__PURE__ */ jsxs12(Fragment2, { children: [
+    hiddenAbove > 0 && /* @__PURE__ */ jsx16(Box13, { paddingX: 1, children: /* @__PURE__ */ jsxs12(Text13, { dimColor: true, children: [
+      "^ ",
+      hiddenAbove,
+      " more message",
+      hiddenAbove !== 1 ? "s" : "",
+      " (Ctrl+P/Ctrl+N)"
+    ] }) }),
+    /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", flexGrow: 1, marginTop: hiddenAbove > 0 ? 0 : 1, children: [
+      visibleMessages.map((msg, i) => /* @__PURE__ */ jsx16(Box13, { marginBottom: 1, flexDirection: "column", children: /* @__PURE__ */ jsx16(MessageDisplay, { message: msg }) }, i)),
+      streamingText && /* @__PURE__ */ jsxs12(Box13, { marginBottom: 1, paddingX: 1, children: [
+        /* @__PURE__ */ jsx16(Box13, { width: 2, children: /* @__PURE__ */ jsx16(Text13, { color: theme.text.accent, children: "\u2726 " }) }),
+        /* @__PURE__ */ jsx16(Box13, { flexShrink: 1, children: /* @__PURE__ */ jsx16(Text13, { color: theme.text.primary, children: streamingText }) })
+      ] }),
+      isGenerating && !streamingText && /* @__PURE__ */ jsx16(ThinkingIndicator, { onCancel: handleCancelGeneration })
+    ] })
+  ] });
+}
+
+// src/tui/composer.tsx
+import { useState as useState7, useMemo as useMemo4 } from "react";
+import { Box as Box14, Text as Text15, useStdout as useStdout3 } from "ink";
+
+// src/tui/resettable-input.tsx
+import { useReducer as useReducer2, useEffect as useEffect6, useRef as useRef7, useCallback as useCallback10 } from "react";
+import { Text as Text14 } from "ink";
+import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+function inputReducer(state, action) {
+  switch (action.type) {
+    case "insert": {
+      const value = state.value.slice(0, state.cursor) + action.text + state.value.slice(state.cursor);
+      return { value, prevValue: state.value, cursor: state.cursor + action.text.length };
+    }
+    case "delete": {
+      if (state.cursor === 0) return state;
+      const value = state.value.slice(0, state.cursor - 1) + state.value.slice(state.cursor);
+      return { value, prevValue: state.value, cursor: state.cursor - 1 };
+    }
+    case "left":
+      return { ...state, cursor: Math.max(0, state.cursor - 1) };
+    case "right":
+      return { ...state, cursor: Math.min(state.value.length, state.cursor + 1) };
+    case "reset":
+      return { value: "", prevValue: state.value, cursor: 0 };
+    case "set":
+      return { value: action.value, prevValue: state.value, cursor: action.cursor };
+  }
+}
+function ResettableInput({ placeholder, onSubmit, onChange, isDisabled, onUpArrow, onDownArrow }) {
+  const [state, dispatch] = useReducer2(inputReducer, { value: "", prevValue: "", cursor: 0 });
+  const submitRef = useRef7(null);
+  useEffect6(() => {
+    if (state.value !== state.prevValue) {
+      onChange?.(state.value);
+    }
+  }, [state.value, state.prevValue, onChange]);
+  useEffect6(() => {
+    if (submitRef.current !== null) {
+      const value = submitRef.current;
+      submitRef.current = null;
+      onSubmit(value);
+    }
+  });
+  useKeypress("resettable-input", KeyPriority.Normal, useCallback10((input, key) => {
+    if (key.ctrl && input === "c" || key.tab || key.shift && key.tab) return false;
+    if (key.upArrow) {
+      if (onUpArrow) {
+        const entry = onUpArrow(state.value);
+        if (entry !== void 0) dispatch({ type: "set", value: entry, cursor: entry.length });
+      }
+      return true;
+    }
+    if (key.downArrow) {
+      if (onDownArrow) {
+        const entry = onDownArrow();
+        if (entry !== void 0) dispatch({ type: "set", value: entry, cursor: entry.length });
+      }
+      return true;
+    }
+    if (key.return) {
+      submitRef.current = state.value;
+      dispatch({ type: "reset" });
+      return true;
+    }
+    if (key.leftArrow) {
+      dispatch({ type: "left" });
+      return true;
+    }
+    if (key.rightArrow) {
+      dispatch({ type: "right" });
+      return true;
+    }
+    if (key.backspace || key.delete) {
+      dispatch({ type: "delete" });
+      return true;
+    }
+    dispatch({ type: "insert", text: input });
+    return true;
+  }, [state.value, onUpArrow, onDownArrow]), !isDisabled);
+  if (state.value.length === 0) {
+    return /* @__PURE__ */ jsxs13(Text14, { children: [
+      /* @__PURE__ */ jsx17(Text14, { inverse: true, children: placeholder?.[0] ?? " " }),
+      /* @__PURE__ */ jsx17(Text14, { dimColor: true, children: placeholder?.slice(1) ?? "" })
+    ] });
+  }
+  const before = state.value.slice(0, state.cursor);
+  const cursorChar = state.value[state.cursor] ?? " ";
+  const after = state.value.slice(state.cursor + 1);
+  return /* @__PURE__ */ jsxs13(Text14, { children: [
+    before,
+    /* @__PURE__ */ jsx17(Text14, { inverse: true, children: cursorChar }),
+    after
+  ] });
+}
+
+// src/tui/use-input-history.ts
+import { useRef as useRef8, useCallback as useCallback11 } from "react";
+function useInputHistory() {
+  const historyRef = useRef8([]);
+  const indexRef = useRef8(-1);
+  const draftRef = useRef8("");
+  const up = useCallback11((currentValue) => {
+    const history = historyRef.current;
+    if (history.length === 0) return void 0;
+    const nextIndex = indexRef.current + 1;
+    if (nextIndex >= history.length) return void 0;
+    if (indexRef.current === -1) {
+      draftRef.current = currentValue;
+    }
+    indexRef.current = nextIndex;
+    return history[nextIndex];
+  }, []);
+  const down = useCallback11(() => {
+    if (indexRef.current === -1) return void 0;
+    const nextIndex = indexRef.current - 1;
+    indexRef.current = nextIndex;
+    if (nextIndex === -1) {
+      return draftRef.current;
+    }
+    return historyRef.current[nextIndex];
+  }, []);
+  const push = useCallback11((value) => {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    if (historyRef.current[0] === trimmed) {
+      indexRef.current = -1;
+      draftRef.current = "";
+      return;
+    }
+    historyRef.current.unshift(trimmed);
+    indexRef.current = -1;
+    draftRef.current = "";
+  }, []);
+  const resetBrowsing = useCallback11(() => {
+    indexRef.current = -1;
+    draftRef.current = "";
+  }, []);
+  return { up, down, push, resetBrowsing };
+}
+
+// src/tui/composer.tsx
+import { Fragment as Fragment3, jsx as jsx18, jsxs as jsxs14 } from "react/jsx-runtime";
+function modeLabel(state) {
+  if (state.isExecuting) return { text: "executing", color: theme.status.warning };
+  if (state.isGenerating) return { text: "generating", color: theme.text.accent };
+  if (state.isConversing) return { text: "conversing", color: theme.text.accent };
+  return { text: "idle", color: theme.text.secondary };
+}
+function daemonLabel(status) {
+  switch (status) {
+    case "running":
+      return "daemon";
+    case "external":
+      return "external";
+    case "starting":
+      return "starting...";
+    default:
+      return "";
+  }
+}
+function Composer() {
+  const { isGenerating, isExecuting, isConversing, daemonStatus, footerExtra, footerHints } = useUIState();
+  const { handleChatSubmit } = useUIActions();
+  const { stdout } = useStdout3();
+  const cols = stdout?.columns ?? 80;
+  const history = useInputHistory();
+  const [currentInput, setCurrentInput] = useState7("");
+  const allCommands = useMemo4(() => getCommands(), []);
+  const matchingCommands = useMemo4(() => {
+    if (!currentInput.startsWith("/")) return [];
+    const prefix = currentInput.toLowerCase();
+    return allCommands.filter((c) => {
+      const full = `/${c.name}`;
+      return full.startsWith(prefix) || c.aliases.some((a) => `/${a}`.startsWith(prefix));
+    });
+  }, [currentInput, allCommands]);
+  const showCommandHints = currentInput.startsWith("/") && matchingCommands.length > 0 && currentInput !== "/" + matchingCommands[0]?.name;
+  const mode = modeLabel({ isExecuting, isGenerating, isConversing });
+  const daemon = daemonLabel(daemonStatus);
+  return /* @__PURE__ */ jsxs14(Fragment3, { children: [
+    /* @__PURE__ */ jsx18(Box14, { paddingX: 1, children: /* @__PURE__ */ jsx18(Text15, { color: theme.border.default, children: "\u2500".repeat(Math.max(0, cols - 2)) }) }),
+    !isGenerating && /* @__PURE__ */ jsxs14(Box14, { paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs14(Box14, { gap: 2, children: [
+        /* @__PURE__ */ jsxs14(Text15, { color: mode.color, children: [
+          "[",
+          mode.text,
+          "]"
+        ] }),
+        footerHints && /* @__PURE__ */ jsx18(Text15, { color: theme.ui.comment, children: footerHints })
+      ] }),
+      /* @__PURE__ */ jsxs14(Box14, { gap: 2, children: [
+        daemon && /* @__PURE__ */ jsx18(Text15, { color: theme.ui.comment, children: daemon }),
+        footerExtra && /* @__PURE__ */ jsx18(Text15, { color: theme.ui.comment, children: footerExtra })
+      ] })
+    ] }),
+    !isGenerating && showCommandHints && /* @__PURE__ */ jsx18(Box14, { flexDirection: "column", paddingX: 2, children: matchingCommands.slice(0, 6).map((cmd) => /* @__PURE__ */ jsxs14(Box14, { gap: 1, children: [
+      /* @__PURE__ */ jsxs14(Text15, { color: theme.status.info, children: [
+        "/",
+        cmd.name
+      ] }),
+      /* @__PURE__ */ jsxs14(Text15, { color: theme.ui.comment, children: [
+        "\u2014",
+        " ",
+        cmd.description
+      ] })
+    ] }, cmd.name)) }),
+    !isGenerating && /* @__PURE__ */ jsx18(Box14, { paddingX: 1, children: /* @__PURE__ */ jsxs14(
+      Box14,
+      {
+        borderStyle: "round",
+        borderColor: theme.border.focused,
+        paddingX: 1,
+        width: cols - 2,
+        children: [
+          /* @__PURE__ */ jsx18(Text15, { color: theme.prompt, children: "> " }),
+          /* @__PURE__ */ jsx18(
+            ResettableInput,
+            {
+              placeholder: "Describe a workflow or type /help",
+              onChange: (value) => {
+                setCurrentInput(value);
+                history.resetBrowsing();
+              },
+              onSubmit: (value) => {
+                const trimmed = value.trim();
+                if (trimmed) {
+                  history.push(trimmed);
+                  setCurrentInput("");
+                  handleChatSubmit(trimmed);
+                }
+              },
+              onUpArrow: history.up,
+              onDownArrow: history.down,
+              isDisabled: isGenerating
+            }
+          )
+        ]
+      }
+    ) })
+  ] });
+}
+
+// src/tui/chat.tsx
+import { jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
+function Chat() {
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx19(MainContent, {}),
+    /* @__PURE__ */ jsx19(Composer, {})
+  ] });
+}
+
+// src/tui/plan-view.tsx
+import { useCallback as useCallback12, memo as memo10 } from "react";
+import { Box as Box16, Text as Text16 } from "ink";
+import { jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
+function PlanView({ workflow, onConfirm, onModify, onCancel }) {
+  useKeypress("plan-view-actions", KeyPriority.Normal, useCallback12((input, key) => {
+    if (keyBindings.confirmPlan(input, key)) {
+      onConfirm();
+      return true;
+    }
+    if (keyBindings.modifyPlan(input, key)) {
+      onModify();
+      return true;
+    }
+    if (keyBindings.cancelPlan(input, key)) {
+      onCancel();
+      return true;
+    }
+    return false;
+  }, [onConfirm, onModify, onCancel]));
+  const trigger = workflow.trigger;
+  const triggerLabel = trigger.type === "manual" ? "manual" : trigger.type === "cron" ? `cron (${trigger.expression})` : `poll (${trigger.interval_seconds}s)`;
+  const failureDesc = workflow.failure_policy.on_step_failure;
+  return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: theme.border.focused, children: [
+      /* @__PURE__ */ jsxs16(Text16, { color: theme.border.accent, bold: true, children: [
+        "Plan: ",
+        workflow.name
+      ] }),
+      /* @__PURE__ */ jsxs16(Text16, { color: theme.ui.comment, children: [
+        "Trigger: ",
+        triggerLabel
+      ] }),
+      /* @__PURE__ */ jsx20(Text16, { children: "" }),
+      workflow.steps.map((step, i) => /* @__PURE__ */ jsx20(StepLine, { step, index: i + 1 }, step.id)),
+      /* @__PURE__ */ jsx20(Text16, { children: "" }),
+      /* @__PURE__ */ jsxs16(Text16, { color: theme.ui.comment, children: [
+        "Failure policy: ",
+        failureDesc
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx20(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs16(Text16, { children: [
+      /* @__PURE__ */ jsx20(Text16, { color: theme.status.success, children: "[Y] Confirm" }),
+      "  ",
+      /* @__PURE__ */ jsx20(Text16, { color: theme.status.warning, children: "[M] Modify" }),
+      "  ",
+      /* @__PURE__ */ jsx20(Text16, { color: theme.status.error, children: "[N] Cancel" })
+    ] }) })
+  ] });
+}
+function stepStatusSymbol(index) {
+  return `\u25CB ${index}.`;
+}
+var StepLine = memo10(function StepLine2({ step, index }) {
+  return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs16(Text16, { color: theme.status.muted, children: [
+      stepStatusSymbol(index),
+      " ",
+      step.description
+    ] }),
+    step.depends_on && step.depends_on.length > 0 && /* @__PURE__ */ jsxs16(Text16, { color: theme.ui.comment, children: [
+      "   \u2514\u2500 depends on: ",
+      step.depends_on.join(", ")
+    ] })
+  ] });
+});
+
+// src/tui/execution-view.tsx
+import { useCallback as useCallback13 } from "react";
+import { Box as Box17, Text as Text17 } from "ink";
+import { jsx as jsx21, jsxs as jsxs17 } from "react/jsx-runtime";
+function ExecutionView({ workflow, stepProgress, output, onBack, onAbort }) {
+  const { isExecuting } = useUIState();
+  const isRunning = Array.from(stepProgress.values()).some((s) => s.status === "running");
+  useKeypress("execution-view-actions", KeyPriority.Normal, useCallback13((input, key) => {
+    if (isExecuting && onAbort && keyBindings.abortExec(input, key)) {
+      onAbort();
+      return true;
+    }
+    if (!isExecuting && onBack && (keyBindings.submit(input, key) || keyBindings.quit(input, key) || keyBindings.escape(input, key))) {
+      onBack();
+      return true;
+    }
+    return false;
+  }, [isExecuting, onAbort, onBack]));
+  return /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs17(Box17, { justifyContent: "space-between", children: [
+        /* @__PURE__ */ jsxs17(Text17, { color: theme.border.accent, bold: true, children: [
+          "Workflow: ",
+          workflow.name
+        ] }),
+        /* @__PURE__ */ jsxs17(Text17, { color: theme.ui.comment, children: [
+          "Status: ",
+          isRunning ? "Running" : "Complete"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx21(Text17, { children: "" }),
+      /* @__PURE__ */ jsx21(Text17, { bold: true, color: theme.text.primary, children: "Steps:" }),
+      workflow.steps.map((step, i) => {
+        const progress = stepProgress.get(step.id);
+        const status = progress?.status ?? "pending";
+        const icon = statusIcon(status);
+        const durationText = progress?.duration ? ` (${formatDuration2(progress.duration)})` : "";
+        return /* @__PURE__ */ jsx21(Box17, { children: /* @__PURE__ */ jsxs17(Text17, { color: statusColor(status), children: [
+          icon,
+          " ",
+          i + 1,
+          ". ",
+          step.description,
+          durationText
+        ] }) }, step.id);
+      }),
+      output.length > 0 && /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: theme.border.default, paddingX: 1, children: [
+        /* @__PURE__ */ jsx21(Text17, { color: theme.ui.comment, children: "Live Output" }),
+        output.slice(-10).map((line, i) => /* @__PURE__ */ jsx21(Text17, { color: theme.text.secondary, children: line }, i))
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx21(Box17, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text17, { color: theme.ui.comment, children: isExecuting ? "Press [X] to cancel" : "Press Enter, Q, or Esc to return to chat" }) })
+  ] });
+}
+function statusIcon(status) {
+  switch (status) {
+    case "succeeded":
+      return "\u2713";
+    case "running":
+      return "\u22B7";
+    case "failed":
+      return "\u2717";
+    case "skipped":
+      return "\u25CB";
+    default:
+      return "\u25CB";
+  }
+}
+function statusColor(status) {
+  switch (status) {
+    case "succeeded":
+      return theme.status.success;
+    case "running":
+      return theme.status.warning;
+    case "failed":
+      return theme.status.error;
+    case "skipped":
+      return theme.status.muted;
+    default:
+      return theme.status.muted;
+  }
+}
+function formatDuration2(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+
+// src/tui/workflow-detail-view.tsx
+import { useState as useState8, useCallback as useCallback14 } from "react";
+import { Box as Box18, Text as Text18 } from "ink";
+import { Fragment as Fragment4, jsx as jsx22, jsxs as jsxs18 } from "react/jsx-runtime";
+function WorkflowDetailView({ workflow, runs, latestStepRuns, onBack, onSelectRun, onStop }) {
+  const [selectedRunIndex, setSelectedRunIndex] = useState8(0);
+  const displayRuns = runs.slice(0, 5);
+  useKeypress("detail-view-actions", KeyPriority.Normal, useCallback14((input, key) => {
+    if (keyBindings.escape(input, key) || keyBindings.quit(input, key)) {
+      onBack();
+      return true;
+    }
+    if (keyBindings.submit(input, key) && displayRuns.length > 0) {
+      onSelectRun(displayRuns[selectedRunIndex].id);
+      return true;
+    }
+    if (keyBindings.stopWorkflow(input, key) && onStop) {
+      onStop();
+      return true;
+    }
+    if (keyBindings.upArrow(input, key) && selectedRunIndex > 0) {
+      setSelectedRunIndex(selectedRunIndex - 1);
+      return true;
+    }
+    if (keyBindings.downArrow(input, key) && selectedRunIndex < displayRuns.length - 1) {
+      setSelectedRunIndex(selectedRunIndex + 1);
+      return true;
+    }
+    return false;
+  }, [onBack, onSelectRun, onStop, displayRuns, selectedRunIndex]));
+  const canStop = workflow.phase === "executing" || workflow.phase === "active";
+  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs18(Box18, { justifyContent: "space-between", children: [
+        /* @__PURE__ */ jsx22(Text18, { color: theme.border.accent, bold: true, children: workflow.name }),
+        /* @__PURE__ */ jsx22(Text18, { color: phaseColor2(workflow.phase), children: workflow.phase })
+      ] }),
+      /* @__PURE__ */ jsx22(Text18, { children: "" }),
+      /* @__PURE__ */ jsxs18(Text18, { color: theme.ui.comment, children: [
+        "ID: ",
+        workflow.id
+      ] }),
+      workflow.description && /* @__PURE__ */ jsx22(Text18, { color: theme.text.secondary, children: workflow.description }),
+      /* @__PURE__ */ jsxs18(Text18, { color: theme.ui.comment, children: [
+        "Trigger: ",
+        formatTrigger(workflow.trigger)
+      ] }),
+      /* @__PURE__ */ jsxs18(Text18, { color: theme.ui.comment, children: [
+        "Failure policy: ",
+        workflow.failure_policy.on_step_failure,
+        " (retries: ",
+        workflow.failure_policy.max_retries,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsxs18(Text18, { color: theme.ui.comment, children: [
+        "Created: ",
+        workflow.created_at,
+        "  Updated: ",
+        workflow.updated_at
+      ] }),
+      /* @__PURE__ */ jsx22(Text18, { children: "" }),
+      /* @__PURE__ */ jsxs18(Text18, { bold: true, color: theme.text.primary, children: [
+        "Steps (",
+        workflow.steps.length,
+        "):"
+      ] }),
+      workflow.steps.map((step, i) => {
+        const deps = step.depends_on.length > 0 ? ` \u2192 depends on: ${step.depends_on.join(", ")}` : "";
+        const stepRun = latestStepRuns.find((sr) => sr.step_id === step.id);
+        const icon = stepRun ? statusIcon2(stepRun.status) : "\u25CB";
+        const iconColor = stepRun ? statusColor2(stepRun.status) : theme.status.muted;
+        return /* @__PURE__ */ jsxs18(Box18, { children: [
+          /* @__PURE__ */ jsxs18(Text18, { color: iconColor, children: [
+            icon,
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs18(Text18, { color: theme.text.secondary, children: [
+            i + 1,
+            ". ",
+            step.description
+          ] }),
+          deps && /* @__PURE__ */ jsx22(Text18, { color: theme.ui.comment, children: deps })
+        ] }, step.id);
+      }),
+      /* @__PURE__ */ jsx22(Text18, { children: "" }),
+      /* @__PURE__ */ jsx22(Text18, { bold: true, color: theme.text.primary, children: "Recent Runs:" }),
+      displayRuns.length === 0 ? /* @__PURE__ */ jsx22(Text18, { dimColor: true, children: "No runs yet." }) : /* @__PURE__ */ jsxs18(Fragment4, { children: [
+        /* @__PURE__ */ jsxs18(Box18, { children: [
+          /* @__PURE__ */ jsx22(Box18, { width: 14, children: /* @__PURE__ */ jsx22(Text18, { bold: true, children: "Status" }) }),
+          /* @__PURE__ */ jsx22(Box18, { width: 24, children: /* @__PURE__ */ jsx22(Text18, { bold: true, children: "Started" }) }),
+          /* @__PURE__ */ jsx22(Box18, { width: 12, children: /* @__PURE__ */ jsx22(Text18, { bold: true, children: "Duration" }) }),
+          /* @__PURE__ */ jsx22(Box18, { children: /* @__PURE__ */ jsx22(Text18, { bold: true, children: "Error" }) })
+        ] }),
+        displayRuns.map((run, i) => /* @__PURE__ */ jsx22(Box18, { children: /* @__PURE__ */ jsxs18(Text18, { inverse: i === selectedRunIndex, children: [
+          /* @__PURE__ */ jsx22(Text18, { color: runStatusColor(run.status), children: run.status.padEnd(14) }),
+          /* @__PURE__ */ jsx22(Text18, { children: run.started_at.slice(0, 22).padEnd(24) }),
+          /* @__PURE__ */ jsx22(Text18, { children: (run.duration_ms != null ? formatDuration3(run.duration_ms) : "\u2014").padEnd(12) }),
+          /* @__PURE__ */ jsx22(Text18, { color: theme.status.error, children: run.error ? run.error.slice(0, 40) : "" })
+        ] }) }, run.id))
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx22(Box18, { marginTop: 1, children: /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+      displayRuns.length > 0 ? "[Enter] View run  " : "",
+      canStop ? "[S] Stop  " : "",
+      "[Q/Esc] Back"
+    ] }) })
+  ] });
+}
+function phaseColor2(phase) {
+  switch (phase) {
+    case "executing":
+      return theme.status.warning;
+    case "active":
+      return theme.status.success;
+    case "completed":
+      return theme.status.success;
+    case "failed":
+      return theme.status.error;
+    case "paused":
+      return theme.status.muted;
+    default:
+      return theme.text.primary;
+  }
+}
+function runStatusColor(status) {
+  switch (status) {
+    case "completed":
+      return theme.status.success;
+    case "running":
+      return theme.status.warning;
+    case "failed":
+      return theme.status.error;
+    default:
+      return theme.text.primary;
+  }
+}
+function statusIcon2(status) {
+  switch (status) {
+    case "succeeded":
+      return "\u2713";
+    case "running":
+      return "\u22B7";
+    case "failed":
+      return "\u2717";
+    case "skipped":
+      return "\u25CB";
+    default:
+      return "\u25CB";
+  }
+}
+function statusColor2(status) {
+  switch (status) {
+    case "succeeded":
+      return theme.status.success;
+    case "running":
+      return theme.status.warning;
+    case "failed":
+      return theme.status.error;
+    case "skipped":
+      return theme.status.muted;
+    default:
+      return theme.status.muted;
+  }
+}
+function formatTrigger(trigger) {
+  switch (trigger.type) {
+    case "poll":
+      return `poll every ${trigger.interval_seconds}s (${trigger.diff_mode})`;
+    case "cron":
+      return `cron: ${trigger.expression}${trigger.timezone ? ` (${trigger.timezone})` : ""}`;
+    case "manual":
+      return "manual";
+  }
+}
+function formatDuration3(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  return `${Math.round(ms / 6e4)}m`;
+}
+
+// src/tui/onboarding.tsx
+import { useState as useState9, useCallback as useCallback15, useMemo as useMemo5 } from "react";
+import { Box as Box19, Text as Text19, useStdout as useStdout4 } from "ink";
+import { TextInput, PasswordInput, ConfirmInput, Spinner, StatusMessage } from "@inkjs/ui";
+import { jsx as jsx23, jsxs as jsxs19 } from "react/jsx-runtime";
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "****" + key.slice(-4);
+}
+function Onboarding({ onComplete, onCancel, issues }) {
+  const { stdout } = useStdout4();
+  const cols = stdout?.columns ?? 80;
+  const existing = useMemo5(() => loadExistingConfig(), []);
+  const initialStep = useMemo5(() => {
+    if (!issues || issues.length === 0) return "welcome";
+    const errorFields = new Set(issues.filter((i) => i.severity === "error").map((i) => i.field));
+    if (errorFields.size === 1 && errorFields.has("claude.api_key")) {
+      return "api_key";
+    }
+    return "welcome";
+  }, [issues]);
+  const [step, setStep] = useState9(initialStep);
+  const [state, setState] = useState9({
+    apiKey: existing.apiKey ?? "",
+    baseUrl: existing.baseUrl ?? "",
+    containerEnabled: existing.containerEnabled ?? false,
+    telegramEnabled: existing.telegramEnabled ?? false,
+    telegramToken: existing.telegramToken ?? "",
+    whatsappEnabled: existing.whatsappEnabled ?? false
+  });
+  const env = checkEnvironment();
+  useKeypress("onboarding-cancel", KeyPriority.Normal, useCallback15((input, key) => {
+    if (onCancel && keyBindings.escape(input, key)) {
+      onCancel();
+      return true;
+    }
+    return false;
+  }, [onCancel]));
+  const gotoApiKey = useCallback15(() => {
+    setStep(existing.apiKey ? "api_key_existing" : "api_key");
+  }, [existing]);
+  const gotoBaseUrl = useCallback15(() => {
+    if (!isDev) return;
+    setStep(existing.baseUrl ? "base_url_existing" : "base_url");
+  }, [existing]);
+  const gotoContainer = useCallback15(() => {
+    if (!(env.docker && env.dockerRunning)) {
+      gotoTelegram();
+      return;
+    }
+    setStep(existing.containerEnabled !== void 0 ? "container_existing" : "container");
+  }, [env, existing]);
+  const gotoTelegram = useCallback15(() => {
+    setStep(existing.telegramEnabled !== void 0 ? "telegram_existing" : "telegram");
+  }, [existing]);
+  const gotoTelegramToken = useCallback15(() => {
+    setStep(existing.telegramToken ? "telegram_token_existing" : "telegram_token");
+  }, [existing]);
+  const gotoWhatsApp = useCallback15(() => {
+    setStep(existing.whatsappEnabled !== void 0 ? "whatsapp_existing" : "whatsapp");
+  }, [existing]);
+  const afterValidation = useCallback15(() => {
+    if (env.docker && env.dockerRunning) {
+      gotoContainer();
+    } else {
+      gotoTelegram();
+    }
+  }, [env, gotoContainer, gotoTelegram]);
+  const handleApiKeySubmit = useCallback15((value) => {
+    const key = value.trim();
+    if (!key) return;
+    setState((s) => ({ ...s, apiKey: key }));
+    if (isDev) {
+      gotoBaseUrl();
+    } else {
+      setStep("validating");
+      doValidation(key, "");
+    }
+  }, [gotoBaseUrl]);
+  const handleBaseUrlSubmit = useCallback15((value) => {
+    const url = value.trim();
+    setState((s) => ({ ...s, baseUrl: url }));
+    setStep("validating");
+    doValidation(state.apiKey, url);
+  }, [state.apiKey]);
+  const doValidation = useCallback15(async (apiKey, baseUrl) => {
+    const prevKey = process.env["ANTHROPIC_API_KEY"];
+    const prevUrl = process.env["ANTHROPIC_BASE_URL"];
+    process.env["ANTHROPIC_API_KEY"] = apiKey;
+    if (baseUrl) {
+      process.env["ANTHROPIC_BASE_URL"] = baseUrl;
+    } else {
+      delete process.env["ANTHROPIC_BASE_URL"];
+    }
+    try {
+      const tempConfig = loadConfig();
+      const result = await validateAuth(tempConfig);
+      if (result.valid) {
+        setState((s) => ({ ...s, validationError: void 0 }));
+        afterValidation();
+      } else {
+        setState((s) => ({ ...s, validationError: result.error }));
+        setStep("api_key");
+      }
+    } catch {
+      setState((s) => ({ ...s, validationError: "Failed to validate API key" }));
+      setStep("api_key");
+    } finally {
+      if (prevKey !== void 0) process.env["ANTHROPIC_API_KEY"] = prevKey;
+      else delete process.env["ANTHROPIC_API_KEY"];
+      if (prevUrl !== void 0) process.env["ANTHROPIC_BASE_URL"] = prevUrl;
+      else delete process.env["ANTHROPIC_BASE_URL"];
+    }
+  }, [afterValidation]);
+  const handleContainerYes = useCallback15(() => {
+    setState((s) => ({ ...s, containerEnabled: true }));
+    gotoTelegram();
+  }, [gotoTelegram]);
+  const handleContainerNo = useCallback15(() => {
+    setState((s) => ({ ...s, containerEnabled: false }));
+    gotoTelegram();
+  }, [gotoTelegram]);
+  const handleTelegramYes = useCallback15(() => {
+    setState((s) => ({ ...s, telegramEnabled: true }));
+    gotoTelegramToken();
+  }, [gotoTelegramToken]);
+  const handleTelegramNo = useCallback15(() => {
+    setState((s) => ({ ...s, telegramEnabled: false }));
+    gotoWhatsApp();
+  }, [gotoWhatsApp]);
+  const handleTelegramTokenSubmit = useCallback15((value) => {
+    setState((s) => ({ ...s, telegramToken: value.trim() }));
+    gotoWhatsApp();
+  }, [gotoWhatsApp]);
+  const finishWithWhatsApp = useCallback15((enabled) => {
+    const next = { ...state, whatsappEnabled: enabled };
+    setState((s) => ({ ...s, whatsappEnabled: enabled }));
+    setStep("saving");
+    doSaveConfig(next);
+  }, [state]);
+  const handleWhatsAppYes = useCallback15(() => finishWithWhatsApp(true), [finishWithWhatsApp]);
+  const handleWhatsAppNo = useCallback15(() => finishWithWhatsApp(false), [finishWithWhatsApp]);
+  const doSaveConfig = useCallback15((finalState) => {
+    if (isDev) {
+      writeEnvVar("ANTHROPIC_API_KEY", finalState.apiKey);
+      if (finalState.baseUrl) {
+        writeEnvVar("ANTHROPIC_BASE_URL", finalState.baseUrl);
+      }
+    } else {
+      const configUpdates = {
+        claude: {
+          api_key: finalState.apiKey,
+          ...finalState.baseUrl ? { base_url: finalState.baseUrl } : {}
+        }
+      };
+      if (finalState.containerEnabled) {
+        configUpdates.container = { enabled: true };
+      }
+      if (finalState.telegramEnabled && finalState.telegramToken) {
+        configUpdates.telegram = {
+          enabled: true,
+          token: finalState.telegramToken
+        };
+      }
+      if (finalState.whatsappEnabled) {
+        configUpdates.whatsapp = { enabled: true };
+      }
+      writeConfig(configUpdates);
+    }
+    const config = loadConfig();
+    setStep("done");
+    setTimeout(() => onComplete(config), 1500);
+  }, [onComplete]);
+  const StepLayout = ({ children, input }) => /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx23(Box19, { flexDirection: "column", flexGrow: 1, children }),
+    /* @__PURE__ */ jsx23(Box19, { marginTop: 1, children: input })
+  ] });
+  return /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    onCancel && /* @__PURE__ */ jsx23(Box19, { justifyContent: "flex-end", children: /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Press Esc to cancel" }) }),
+    step === "welcome" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(
+          TextInput,
+          {
+            placeholder: "Press Enter to continue...",
+            onSubmit: () => gotoApiKey()
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, color: "cyan", children: "Welcome to CueClaw" }),
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "First time? Let's set up CueClaw." }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "\u2500".repeat(Math.max(0, cols - 2)) }),
+          /* @__PURE__ */ jsxs19(Box19, { marginTop: 1, children: [
+            /* @__PURE__ */ jsx23(Text19, { children: "Press " }),
+            /* @__PURE__ */ jsx23(Text19, { bold: true, color: "green", children: "Enter" }),
+            /* @__PURE__ */ jsx23(Text19, { children: " to begin setup" })
+          ] })
+        ]
+      }
+    ),
+    step === "api_key_existing" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(
+          ConfirmInput,
+          {
+            onConfirm: () => {
+              if (isDev) gotoBaseUrl();
+              else {
+                setStep("validating");
+                doValidation(state.apiKey, state.baseUrl);
+              }
+            },
+            onCancel: () => setStep("api_key")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 1: API Key" }),
+          /* @__PURE__ */ jsxs19(Text19, { children: [
+            "Found existing API key: ",
+            /* @__PURE__ */ jsx23(Text19, { color: "yellow", children: maskKey(existing.apiKey) })
+          ] }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Keep this key?" })
+        ]
+      }
+    ),
+    step === "api_key" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsxs19(Box19, { children: [
+          /* @__PURE__ */ jsx23(Text19, { color: "green", children: "> " }),
+          /* @__PURE__ */ jsx23(PasswordInput, { placeholder: "sk-ant-...", onSubmit: handleApiKeySubmit })
+        ] }),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 1: API Key" }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Enter your Anthropic API key (or compatible provider key)" }),
+          state.validationError && /* @__PURE__ */ jsx23(Box19, { marginY: 1, children: /* @__PURE__ */ jsx23(StatusMessage, { variant: "error", children: state.validationError }) })
+        ]
+      }
+    ),
+    step === "base_url_existing" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(
+          ConfirmInput,
+          {
+            onConfirm: () => {
+              setStep("validating");
+              doValidation(state.apiKey, state.baseUrl);
+            },
+            onCancel: () => setStep("base_url")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 1b: Base URL" }),
+          /* @__PURE__ */ jsxs19(Text19, { children: [
+            "Found existing base URL: ",
+            /* @__PURE__ */ jsx23(Text19, { color: "yellow", children: existing.baseUrl })
+          ] }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Keep this URL?" })
+        ]
+      }
+    ),
+    step === "base_url" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsxs19(Box19, { children: [
+          /* @__PURE__ */ jsx23(Text19, { color: "green", children: "> " }),
+          /* @__PURE__ */ jsx23(TextInput, { placeholder: "https://api.anthropic.com", onSubmit: handleBaseUrlSubmit })
+        ] }),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 1b: Base URL (optional)" }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Custom API base URL (leave empty for api.anthropic.com)" })
+        ]
+      }
+    ),
+    step === "validating" && /* @__PURE__ */ jsx23(Box19, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx23(Spinner, { label: "Validating API key..." }) }),
+    step === "container_existing" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(
+          ConfirmInput,
+          {
+            onConfirm: () => gotoTelegram(),
+            onCancel: () => setStep("container")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 2: Container Isolation" }),
+          /* @__PURE__ */ jsxs19(Text19, { children: [
+            "Container isolation is already ",
+            /* @__PURE__ */ jsx23(Text19, { color: "yellow", children: existing.containerEnabled ? "enabled" : "disabled" }),
+            "."
+          ] }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Keep this setting?" })
+        ]
+      }
+    ),
+    step === "container" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(ConfirmInput, { onConfirm: handleContainerYes, onCancel: handleContainerNo }),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 2: Container Isolation" }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Docker detected. Enable container isolation for safer execution?" })
+        ]
+      }
+    ),
+    step === "telegram_existing" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(
+          ConfirmInput,
+          {
+            onConfirm: () => {
+              if (state.telegramEnabled) gotoTelegramToken();
+              else gotoWhatsApp();
+            },
+            onCancel: () => setStep("telegram")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 3: Telegram Bot" }),
+          /* @__PURE__ */ jsxs19(Text19, { children: [
+            "Telegram bot is already ",
+            /* @__PURE__ */ jsx23(Text19, { color: "yellow", children: existing.telegramEnabled ? "enabled" : "disabled" }),
+            "."
+          ] }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Keep this setting?" })
+        ]
+      }
+    ),
+    step === "telegram" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(ConfirmInput, { onConfirm: handleTelegramYes, onCancel: handleTelegramNo }),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 3: Telegram Bot" }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Set up a Telegram bot for remote workflow management?" })
+        ]
+      }
+    ),
+    step === "telegram_token_existing" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(
+          ConfirmInput,
+          {
+            onConfirm: () => gotoWhatsApp(),
+            onCancel: () => setStep("telegram_token")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Telegram Bot Token" }),
+          /* @__PURE__ */ jsxs19(Text19, { children: [
+            "Found existing token: ",
+            /* @__PURE__ */ jsx23(Text19, { color: "yellow", children: maskKey(existing.telegramToken) })
+          ] }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Keep this token?" })
+        ]
+      }
+    ),
+    step === "telegram_token" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsxs19(Box19, { children: [
+          /* @__PURE__ */ jsx23(Text19, { color: "green", children: "> " }),
+          /* @__PURE__ */ jsx23(PasswordInput, { placeholder: "123456:ABC...", onSubmit: handleTelegramTokenSubmit })
+        ] }),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Telegram Bot Token" }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Paste the token from @BotFather" })
+        ]
+      }
+    ),
+    step === "whatsapp_existing" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(
+          ConfirmInput,
+          {
+            onConfirm: () => finishWithWhatsApp(state.whatsappEnabled),
+            onCancel: () => setStep("whatsapp")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 4: WhatsApp" }),
+          /* @__PURE__ */ jsxs19(Text19, { children: [
+            "WhatsApp is already ",
+            /* @__PURE__ */ jsx23(Text19, { color: "yellow", children: existing.whatsappEnabled ? "enabled" : "disabled" }),
+            "."
+          ] }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Keep this setting?" })
+        ]
+      }
+    ),
+    step === "whatsapp" && /* @__PURE__ */ jsxs19(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx23(ConfirmInput, { onConfirm: handleWhatsAppYes, onCancel: handleWhatsAppNo }),
+        children: [
+          /* @__PURE__ */ jsx23(Text19, { bold: true, children: "Step 4: WhatsApp" }),
+          /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Enable WhatsApp channel? (Requires QR scan on daemon start)" })
+        ]
+      }
+    ),
+    step === "saving" && /* @__PURE__ */ jsx23(Box19, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx23(Spinner, { label: "Saving configuration..." }) }),
+    step === "done" && /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx23(StatusMessage, { variant: "success", children: "Configuration saved!" }),
+      /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [
+        /* @__PURE__ */ jsxs19(Text19, { dimColor: true, children: [
+          "API Key: ****",
+          state.apiKey.slice(-4)
+        ] }),
+        state.baseUrl && /* @__PURE__ */ jsxs19(Text19, { dimColor: true, children: [
+          "Base URL: ",
+          state.baseUrl
+        ] }),
+        state.containerEnabled && /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Container isolation: enabled" }),
+        state.telegramEnabled && /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "Telegram bot: configured" }),
+        state.whatsappEnabled && /* @__PURE__ */ jsx23(Text19, { dimColor: true, children: "WhatsApp: enabled" })
+      ] }),
+      /* @__PURE__ */ jsx23(Box19, { marginTop: 1, children: /* @__PURE__ */ jsx23(Text19, { children: "Starting CueClaw..." }) })
+    ] })
+  ] });
+}
+
+// src/tui/status.tsx
+import { useState as useState10, useCallback as useCallback16, useEffect as useEffect7 } from "react";
+import { Box as Box20, Text as Text20 } from "ink";
+import { Fragment as Fragment5, jsx as jsx24, jsxs as jsxs20 } from "react/jsx-runtime";
+function Status({ workflows, onSelect, onBack, onStop, onDelete }) {
+  const [selectedIndex, setSelectedIndex] = useState10(0);
+  const [confirm, setConfirm] = useState10(null);
+  const [message, setMessage] = useState10(null);
+  useEffect7(() => {
+    if (!message) return;
+    const timer = setTimeout(() => setMessage(null), 3e3);
+    return () => clearTimeout(timer);
+  }, [message]);
+  useKeypress("status-view", KeyPriority.Normal, useCallback16((input, key) => {
+    if (confirm) {
+      if (keyBindings.confirmYes(input, key)) {
+        const wf = workflows.find((w) => w.id === confirm.workflowId);
+        if (wf) {
+          if (confirm.type === "stop" && onStop) {
+            onStop(wf);
+            setMessage(`Stopped "${wf.name}"`);
+          } else if (confirm.type === "delete" && onDelete) {
+            onDelete(wf);
+            setMessage(`Deleted "${wf.name}"`);
+          }
+        }
+        setConfirm(null);
+        return true;
+      } else if (keyBindings.confirmNo(input, key)) {
+        setConfirm(null);
+        return true;
+      }
+      return true;
+    }
+    if (message) setMessage(null);
+    if (keyBindings.upArrow(input, key) && selectedIndex > 0) {
+      setSelectedIndex(selectedIndex - 1);
+      return true;
+    }
+    if (keyBindings.downArrow(input, key) && selectedIndex < workflows.length - 1) {
+      setSelectedIndex(selectedIndex + 1);
+      return true;
+    }
+    if (keyBindings.submit(input, key) && workflows.length > 0) {
+      onSelect(workflows[selectedIndex]);
+      return true;
+    }
+    const selected = workflows[selectedIndex];
+    if (keyBindings.stopWorkflow(input, key) && onStop && selected && (selected.phase === "executing" || selected.phase === "active")) {
+      setConfirm({ type: "stop", workflowId: selected.id });
+      return true;
+    }
+    if (keyBindings.deleteWorkflow(input, key) && onDelete && selected) {
+      setConfirm({ type: "delete", workflowId: selected.id });
+      return true;
+    }
+    if (keyBindings.escape(input, key) || keyBindings.quit(input, key)) {
+      onBack();
+      return true;
+    }
+    return false;
+  }, [confirm, message, selectedIndex, workflows, onSelect, onBack, onStop, onDelete]));
+  const phaseColor3 = (phase) => {
+    switch (phase) {
+      case "executing":
+        return theme.status.warning;
+      case "active":
+        return theme.status.success;
+      case "completed":
+        return theme.status.success;
+      case "failed":
+        return theme.status.error;
+      case "paused":
+        return theme.status.muted;
+      default:
+        return theme.text.primary;
+    }
+  };
+  return /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx24(Text20, { bold: true, color: theme.border.accent, children: "Workflows" }),
+      /* @__PURE__ */ jsx24(Text20, { children: "" }),
+      workflows.length === 0 ? /* @__PURE__ */ jsx24(Text20, { dimColor: true, children: "No workflows found. Type a description to create one." }) : /* @__PURE__ */ jsxs20(Fragment5, { children: [
+        /* @__PURE__ */ jsxs20(Box20, { children: [
+          /* @__PURE__ */ jsx24(Box20, { width: 14, children: /* @__PURE__ */ jsx24(Text20, { bold: true, children: "ID" }) }),
+          /* @__PURE__ */ jsx24(Box20, { width: 28, children: /* @__PURE__ */ jsx24(Text20, { bold: true, children: "Name" }) }),
+          /* @__PURE__ */ jsx24(Box20, { width: 14, children: /* @__PURE__ */ jsx24(Text20, { bold: true, children: "Phase" }) })
+        ] }),
+        workflows.map((wf, i) => /* @__PURE__ */ jsx24(Box20, { children: /* @__PURE__ */ jsxs20(Text20, { inverse: i === selectedIndex, children: [
+          /* @__PURE__ */ jsx24(Text20, { children: wf.id.slice(0, 12).padEnd(14) }),
+          /* @__PURE__ */ jsx24(Text20, { children: wf.name.slice(0, 26).padEnd(28) }),
+          /* @__PURE__ */ jsx24(Text20, { color: phaseColor3(wf.phase), children: wf.phase })
+        ] }) }, wf.id))
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", marginTop: 1, children: [
+      message && /* @__PURE__ */ jsx24(Text20, { bold: true, color: theme.status.success, children: message }),
+      confirm ? /* @__PURE__ */ jsxs20(Text20, { bold: true, color: theme.status.warning, children: [
+        confirm.type === "stop" ? "Stop" : "Delete",
+        " workflow ",
+        confirm.workflowId.slice(0, 12),
+        "? [Y]es / [N]o"
+      ] }) : /* @__PURE__ */ jsx24(Text20, { dimColor: true, children: "[Enter] View  [S] Stop  [X] Delete  [Q] Back" })
+    ] })
+  ] });
+}
+
+// src/tui/app-layout.tsx
+import { jsx as jsx25, jsxs as jsxs21 } from "react/jsx-runtime";
+function AppLayout({ cwd }) {
+  const { view, workflow, stepProgress, executionOutput, config, statusWorkflows, detailRuns, detailStepRuns } = useUIState();
+  const { handleConfirm, handleModify, handleCancel, handleExecutionAbort, handleExecutionBack, handleOnboardingComplete, handleOnboardingCancel, handleStatusBack, handleStatusSelect, handleStatusStop, handleStatusDelete, handleDetailBack, handleDetailSelectRun } = useUIActions();
+  const { stdout } = useStdout5();
+  const rows = stdout?.rows ?? 24;
+  const displayPath = cwd ? cwd.replace(process.env["HOME"] ?? "", "~") : "";
+  const versionLabel = appVersion === "dev" ? "dev" : `v${appVersion}`;
+  const configIssues = useMemo6(() => {
+    const validation = validateConfig();
+    return validation.issues.filter((i) => i.severity === "error");
+  }, []);
+  return /* @__PURE__ */ jsxs21(Box21, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx25(Static, { items: view !== "onboarding" ? ["banner"] : [], children: (item) => /* @__PURE__ */ jsx25(
+      Banner,
+      {
+        version: versionLabel,
+        cwd: displayPath,
+        terminalWidth: stdout?.columns ?? 80
+      },
+      item
+    ) }),
+    view === "onboarding" && /* @__PURE__ */ jsx25(Onboarding, { onComplete: handleOnboardingComplete, onCancel: config ? handleOnboardingCancel : void 0, issues: configIssues }),
+    view === "chat" && /* @__PURE__ */ jsx25(Chat, {}),
+    view === "plan" && workflow && /* @__PURE__ */ jsx25(
+      PlanView,
+      {
+        workflow,
+        onConfirm: handleConfirm,
+        onModify: handleModify,
+        onCancel: handleCancel
+      }
+    ),
+    view === "execution" && workflow && /* @__PURE__ */ jsx25(
+      ExecutionView,
+      {
+        workflow,
+        stepProgress,
+        output: executionOutput,
+        onBack: handleExecutionBack,
+        onAbort: handleExecutionAbort
+      }
+    ),
+    view === "status" && /* @__PURE__ */ jsx25(
+      Status,
+      {
+        workflows: statusWorkflows,
+        onBack: handleStatusBack,
+        onSelect: handleStatusSelect,
+        onStop: handleStatusStop,
+        onDelete: handleStatusDelete
+      }
+    ),
+    view === "detail" && workflow && /* @__PURE__ */ jsx25(
+      WorkflowDetailView,
+      {
+        workflow,
+        runs: detailRuns,
+        latestStepRuns: detailStepRuns,
+        onBack: handleDetailBack,
+        onSelectRun: handleDetailSelectRun
+      }
+    )
+  ] });
+}
+
+// src/tui/app.tsx
+import { jsx as jsx26 } from "react/jsx-runtime";
+function App({ cwd, skipOnboarding }) {
+  return /* @__PURE__ */ jsx26(ThemeProvider, { theme: cueclawTheme, children: /* @__PURE__ */ jsx26(KeypressProvider, { children: /* @__PURE__ */ jsx26(DialogManager, { children: /* @__PURE__ */ jsx26(AppProvider, { cwd, skipOnboarding, children: /* @__PURE__ */ jsx26(AppLayout, { cwd }) }) }) }) });
+}
+export {
+  App
+};