cueclaw 0.0.4 → 0.1.1

package/dist/app-ZJG6ANUK.js

@@ -0,0 +1,1953 @@
+import {
+  TriggerLoop
+} from "./chunk-W274JWEK.js";
+import {
+  getServiceStatus
+} from "./chunk-PZZ6FBGB.js";
+import {
+  checkEnvironment,
+  validateAuth
+} from "./chunk-KRNAXOQ4.js";
+import {
+  MessageRouter
+} from "./chunk-LSL3FRCU.js";
+import {
+  askQuestionTool,
+  buildPlannerSystemPrompt,
+  confirmPlan,
+  parsePlannerToolResponse,
+  plannerTool,
+  rejectPlan,
+  setSecretTool
+} from "./chunk-WE5J7GMR.js";
+import {
+  createAnthropicClient
+} from "./chunk-DVQFSFIZ.js";
+import {
+  isDev,
+  writeEnvVar
+} from "./chunk-ZCK3IFLC.js";
+import {
+  executeWorkflow
+} from "./chunk-SEYPA5M2.js";
+import {
+  deleteWorkflow,
+  getStepRunsByRunId,
+  getWorkflow,
+  getWorkflowRunsByWorkflowId,
+  initDb,
+  insertWorkflow,
+  listWorkflows,
+  updateWorkflowPhase
+} from "./chunk-G43R5ASK.js";
+import {
+  cueclawHome,
+  loadConfig,
+  loadExistingConfig,
+  validateConfig,
+  writeConfig
+} from "./chunk-RSKXBXSJ.js";
+import "./chunk-BVQG3WYO.js";
+import {
+  logger,
+  onLogLine
+} from "./chunk-QBOYMF4A.js";
+
+// src/tui/app.tsx
+import React2, { useReducer as useReducer2, useCallback as useCallback2, useMemo as useMemo3, useState as useState3, useEffect as useEffect2, useRef as useRef2 } from "react";
+import { Box as Box6, Text as Text6, Static, useInput as useInput4, useApp, useStdout as useStdout3 } from "ink";
+import { ThemeProvider, ConfirmInput as ConfirmInput2 } from "@inkjs/ui";
+
+// src/tui/theme.ts
+import { extendTheme, defaultTheme } from "@inkjs/ui";
+var cueclawTheme = extendTheme(defaultTheme, {
+  components: {
+    Header: {
+      styles: {
+        hints: () => ({ color: "white", dimColor: true })
+      }
+    },
+    PlanView: {
+      styles: {
+        title: () => ({ color: "cyan", bold: true }),
+        stepPending: () => ({ color: "gray" }),
+        stepRunning: () => ({ color: "yellow" }),
+        stepDone: () => ({ color: "green" }),
+        stepFailed: () => ({ color: "red" }),
+        border: () => ({ borderColor: "gray" })
+      }
+    },
+    StatusDashboard: {
+      styles: {
+        executing: () => ({ color: "yellow" }),
+        completed: () => ({ color: "green" }),
+        failed: () => ({ color: "red" }),
+        paused: () => ({ color: "gray", dimColor: true })
+      }
+    },
+    Chat: {
+      styles: {
+        userMessage: () => ({ color: "white", bold: true }),
+        systemMessage: () => ({ color: "cyan" }),
+        assistantMessage: () => ({ color: "white" }),
+        prompt: () => ({ color: "green" })
+      }
+    }
+  }
+});
+
+// src/tui/chat.tsx
+import { useState, useMemo, useReducer, useEffect, useRef } from "react";
+import { Box, Text, useStdout, useInput } from "ink";
+import { Spinner, useComponentTheme } from "@inkjs/ui";
+
+// 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.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() };
+}
+registerCommand({
+  name: "help",
+  aliases: ["h", "?"],
+  description: "Show available commands",
+  usage: "/help",
+  execute(_args, ctx) {
+    const lines = commands.map((c) => {
+      const aliases = c.aliases.length > 0 ? ` (${c.aliases.map((a) => "/" + a).join(", ")})` : "";
+      return `  /${c.name}${aliases} \u2014 ${c.description}`;
+    });
+    ctx.addMessage({ role: "assistant", text: "Available commands:\n" + lines.join("\n") });
+  }
+});
+registerCommand({
+  name: "list",
+  aliases: ["ls"],
+  description: "List all workflows",
+  usage: "/list",
+  execute(_args, ctx) {
+    const workflows = listWorkflows(ctx.db);
+    if (workflows.length === 0) {
+      ctx.addMessage({ role: "assistant", text: "No workflows found." });
+      return;
+    }
+    const header = `${"ID".padEnd(14)} ${"Name".padEnd(28)} ${"Phase".padEnd(14)} Trigger`;
+    const rows = workflows.map((wf) => {
+      const trigger = wf.trigger.type === "poll" ? `poll (${wf.trigger.interval_seconds}s)` : wf.trigger.type === "cron" ? `cron (${wf.trigger.expression})` : "manual";
+      return `${wf.id.slice(0, 12).padEnd(14)} ${wf.name.slice(0, 26).padEnd(28)} ${wf.phase.padEnd(14)} ${trigger}`;
+    });
+    ctx.addMessage({ role: "assistant", text: `Workflows (${workflows.length}):
+${header}
+${rows.join("\n")}` });
+  }
+});
+registerCommand({
+  name: "status",
+  aliases: ["st"],
+  description: "View workflow status",
+  usage: "/status [id]",
+  execute(args, ctx) {
+    if (!args) {
+      findCommand("list").execute("", ctx);
+      return;
+    }
+    const wf = getWorkflow(ctx.db, args) ?? findWorkflowByPrefix(ctx.db, args);
+    if (!wf) {
+      ctx.addMessage({ role: "assistant", text: `Workflow not found: ${args}` });
+      return;
+    }
+    const trigger = wf.trigger.type === "poll" ? `poll (${wf.trigger.interval_seconds}s)` : wf.trigger.type === "cron" ? `cron (${wf.trigger.expression})` : "manual";
+    let detail = `Workflow: ${wf.name}
+ID: ${wf.id}
+Phase: ${wf.phase}
+Trigger: ${trigger}
+Created: ${wf.created_at}
+
+Steps:`;
+    for (const step of wf.steps) {
+      const deps = step.depends_on.length > 0 ? ` (after: ${step.depends_on.join(", ")})` : "";
+      detail += `
+  - ${step.id}: ${step.description.slice(0, 80)}${deps}`;
+    }
+    const runs = getWorkflowRunsByWorkflowId(ctx.db, wf.id);
+    if (runs.length > 0) {
+      const latest = runs[0];
+      detail += `
+
+Latest Run: ${latest.status}`;
+      if (latest.error) detail += ` \u2014 ${latest.error}`;
+      const stepRuns = getStepRunsByRunId(ctx.db, latest.id);
+      if (stepRuns.length > 0) {
+        detail += "\nStep Results:";
+        for (const sr of stepRuns) {
+          const output = sr.output_json ? ` \u2014 ${sr.output_json.slice(0, 60)}` : "";
+          detail += `
+  ${sr.step_id}: ${sr.status}${output}`;
+        }
+      }
+    }
+    ctx.addMessage({ role: "assistant", text: detail });
+  }
+});
+registerCommand({
+  name: "pause",
+  aliases: [],
+  description: "Pause a workflow",
+  usage: "/pause <id>",
+  execute(args, ctx) {
+    if (!args) {
+      ctx.addMessage({ role: "assistant", text: "Usage: /pause <workflow-id>" });
+      return;
+    }
+    const wf = getWorkflow(ctx.db, args) ?? findWorkflowByPrefix(ctx.db, args);
+    if (!wf) {
+      ctx.addMessage({ role: "assistant", text: `Workflow not found: ${args}` });
+      return;
+    }
+    if (wf.phase !== "active") {
+      ctx.addMessage({ role: "assistant", text: `Cannot pause workflow in phase "${wf.phase}" (must be "active")` });
+      return;
+    }
+    updateWorkflowPhase(ctx.db, wf.id, "paused");
+    ctx.addMessage({ role: "assistant", text: `Paused workflow "${wf.name}" (${wf.id})` });
+  }
+});
+registerCommand({
+  name: "resume",
+  aliases: [],
+  description: "Resume a paused workflow",
+  usage: "/resume <id>",
+  execute(args, ctx) {
+    if (!args) {
+      ctx.addMessage({ role: "assistant", text: "Usage: /resume <workflow-id>" });
+      return;
+    }
+    const wf = getWorkflow(ctx.db, args) ?? findWorkflowByPrefix(ctx.db, args);
+    if (!wf) {
+      ctx.addMessage({ role: "assistant", text: `Workflow not found: ${args}` });
+      return;
+    }
+    if (wf.phase !== "paused") {
+      ctx.addMessage({ role: "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({ role: "assistant", text: `Resumed workflow "${wf.name}" \u2014 phase: ${nextPhase}` });
+  }
+});
+registerCommand({
+  name: "delete",
+  aliases: ["rm"],
+  description: "Delete a workflow",
+  usage: "/delete <id>",
+  execute(args, ctx) {
+    if (!args) {
+      ctx.addMessage({ role: "assistant", text: "Usage: /delete <workflow-id>" });
+      return;
+    }
+    const wf = getWorkflow(ctx.db, args) ?? findWorkflowByPrefix(ctx.db, args);
+    if (!wf) {
+      ctx.addMessage({ role: "assistant", text: `Workflow not found: ${args}` });
+      return;
+    }
+    if (wf.phase === "executing") {
+      ctx.addMessage({ role: "assistant", text: "Cannot delete workflow while it is executing." });
+      return;
+    }
+    deleteWorkflow(ctx.db, wf.id);
+    ctx.addMessage({ role: "assistant", text: `Deleted workflow "${wf.name}" (${wf.id})` });
+  }
+});
+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({ role: "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({ role: "assistant", text: value !== void 0 ? `${key} = ${JSON.stringify(value, null, 2)}` : `Key not found: ${key}` });
+      } catch (err) {
+        ctx.addMessage({ role: "assistant", 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({ role: "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({ role: "assistant", text: `Set ${key} = ${JSON.stringify(parsed)}` });
+      } catch (err) {
+        ctx.addMessage({ role: "assistant", text: `Error setting config: ${err instanceof Error ? err.message : String(err)}` });
+      }
+      return;
+    }
+    ctx.addMessage({ role: "assistant", text: "Usage: /config get [key] | /config set <key> <value>" });
+  }
+});
+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({ role: "assistant", text: `Daemon status: ${status}
+Bridge: ${bridgeStatus}` });
+      return;
+    }
+    if (subcommand === "start" || subcommand === "stop") {
+      ctx.addMessage({ role: "assistant", text: `Use the CLI for daemon ${subcommand}: cueclaw daemon ${subcommand}` });
+      return;
+    }
+    ctx.addMessage({ role: "assistant", text: "Usage: /daemon status|start|stop" });
+  }
+});
+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({ role: "assistant", text: lines.join("\n") });
+  }
+});
+registerCommand({
+  name: "clear",
+  aliases: ["cls"],
+  description: "Clear chat messages",
+  usage: "/clear",
+  execute(_args, ctx) {
+    ctx.clearMessages();
+  }
+});
+registerCommand({
+  name: "new",
+  aliases: [],
+  description: "Generate a plan directly (skip conversation)",
+  usage: "/new <description>",
+  execute(args, ctx) {
+    if (!args) {
+      ctx.addMessage({ role: "assistant", text: "Usage: /new <workflow description>" });
+      return;
+    }
+    ctx.addMessage({ role: "assistant", text: "Generating plan..." });
+  }
+});
+registerCommand({
+  name: "cancel",
+  aliases: [],
+  description: "Cancel current conversation",
+  usage: "/cancel",
+  execute(_args, ctx) {
+    ctx.addMessage({ role: "assistant", text: "Conversation cancelled." });
+  }
+});
+registerCommand({
+  name: "bot",
+  aliases: [],
+  description: "Manage bot channels",
+  usage: "/bot start|status",
+  execute(args, ctx) {
+    const subcommand = args.trim().toLowerCase() || "status";
+    if (subcommand === "status") {
+      const config = ctx.config;
+      const tg = config?.telegram?.enabled ? "enabled" : "disabled";
+      const wa = config?.whatsapp?.enabled ? "enabled" : "disabled";
+      ctx.addMessage({ role: "assistant", text: `Telegram: ${tg}
+WhatsApp: ${wa}` });
+      return;
+    }
+    if (subcommand === "start") {
+      return;
+    }
+    ctx.addMessage({ role: "assistant", text: "Usage: /bot start|status" });
+  }
+});
+registerCommand({
+  name: "setup",
+  aliases: [],
+  description: "Re-run configuration setup",
+  usage: "/setup",
+  execute(_args, ctx) {
+    ctx.addMessage({ role: "assistant", text: "Starting setup wizard..." });
+  }
+});
+function findWorkflowByPrefix(db, prefix) {
+  const all = listWorkflows(db);
+  return all.find((wf) => wf.id.startsWith(prefix));
+}
+
+// src/tui/chat.tsx
+import { jsx, jsxs } 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 };
+  }
+}
+function ResettableInput({ placeholder, onSubmit, onChange, isDisabled }) {
+  const [state, dispatch] = useReducer(inputReducer, { value: "", prevValue: "", cursor: 0 });
+  const submitRef = useRef(null);
+  useEffect(() => {
+    if (state.value !== state.prevValue) {
+      onChange?.(state.value);
+    }
+  }, [state.value, state.prevValue, onChange]);
+  useEffect(() => {
+    if (submitRef.current !== null) {
+      const value = submitRef.current;
+      submitRef.current = null;
+      onSubmit(value);
+    }
+  });
+  useInput((input, key) => {
+    if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) return;
+    if (key.return) {
+      submitRef.current = state.value;
+      dispatch({ type: "reset" });
+      return;
+    }
+    if (key.leftArrow) {
+      dispatch({ type: "left" });
+      return;
+    }
+    if (key.rightArrow) {
+      dispatch({ type: "right" });
+      return;
+    }
+    if (key.backspace || key.delete) {
+      dispatch({ type: "delete" });
+      return;
+    }
+    dispatch({ type: "insert", text: input });
+  }, { isActive: !isDisabled });
+  if (state.value.length === 0) {
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: placeholder?.[0] ?? " " }),
+      /* @__PURE__ */ jsx(Text, { 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__ */ jsxs(Text, { children: [
+    before,
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: cursorChar }),
+    after
+  ] });
+}
+function Chat({ messages, isGenerating, onSubmit, footerExtra, footerHints, streamingText }) {
+  const { styles } = useComponentTheme("Chat");
+  const { styles: headerStyles } = useComponentTheme("Header");
+  const userStyle = styles?.userMessage?.() ?? { color: "white", bold: true };
+  const systemStyle = styles?.systemMessage?.() ?? { color: "cyan" };
+  const assistantStyle = styles?.assistantMessage?.() ?? { color: "white" };
+  const promptStyle = styles?.prompt?.() ?? { color: "green" };
+  const hintsStyle = headerStyles?.hints?.() ?? { color: "white", dimColor: true };
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const [currentInput, setCurrentInput] = useState("");
+  const allCommands = useMemo(() => getCommands(), []);
+  const matchingCommands = useMemo(() => {
+    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 defaultHints = "Enter send \xB7 /help commands \xB7 Ctrl+C exit";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, marginTop: 1, children: [
+      messages.map((msg, i) => /* @__PURE__ */ jsx(Box, { marginBottom: 1, flexDirection: "column", children: msg.role === "user" ? /* @__PURE__ */ jsxs(Text, { ...userStyle, children: [
+        "You: ",
+        msg.text
+      ] }) : msg.role === "assistant" ? msg.content ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(Text, { ...assistantStyle, bold: true, children: "CueClaw:" }),
+        msg.content
+      ] }) : /* @__PURE__ */ jsxs(Text, { ...assistantStyle, children: [
+        "CueClaw: ",
+        msg.text
+      ] }) : /* @__PURE__ */ jsx(Text, { ...systemStyle, children: msg.text }) }, i)),
+      streamingText && /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsxs(Text, { ...assistantStyle, children: [
+        "CueClaw: ",
+        streamingText
+      ] }) }),
+      isGenerating && !streamingText && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Spinner, { label: "Thinking..." }) })
+    ] }),
+    !isGenerating && /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { ...promptStyle, children: "> " }),
+      /* @__PURE__ */ jsx(
+        ResettableInput,
+        {
+          placeholder: "Describe a workflow or type /help",
+          onChange: setCurrentInput,
+          onSubmit: (value) => {
+            const trimmed = value.trim();
+            if (trimmed) {
+              setCurrentInput("");
+              onSubmit(trimmed);
+            }
+          },
+          isDisabled: isGenerating
+        }
+      )
+    ] }),
+    !isGenerating && showCommandHints && /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 2, children: matchingCommands.slice(0, 6).map((cmd) => /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        "/",
+        cmd.name
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "\u2014 ",
+        cmd.description
+      ] })
+    ] }, cmd.name)) }),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(Math.max(0, cols - 2)) }) }),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsxs(Text, { ...hintsStyle, children: [
+      footerHints ?? defaultHints,
+      footerExtra ?? ""
+    ] }) })
+  ] });
+}
+
+// src/tui/plan-view.tsx
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import { useComponentTheme as useComponentTheme2 } from "@inkjs/ui";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function PlanView({ workflow, onConfirm, onModify, onCancel }) {
+  const { styles } = useComponentTheme2("PlanView");
+  const titleStyle = styles?.title?.() ?? { color: "cyan", bold: true };
+  const pendingStyle = styles?.stepPending?.() ?? { color: "gray" };
+  const borderStyle = styles?.border?.() ?? { borderColor: "gray" };
+  useInput2((input) => {
+    if (input === "y" || input === "Y") onConfirm();
+    if (input === "m" || input === "M") onModify();
+    if (input === "n" || input === "N") 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__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, borderStyle: "round", ...borderStyle, children: [
+      /* @__PURE__ */ jsxs2(Text2, { ...titleStyle, children: [
+        "Plan: ",
+        workflow.name
+      ] }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "Trigger: ",
+        triggerLabel
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { children: "" }),
+      workflow.steps.map((step, i) => /* @__PURE__ */ jsx2(StepLine, { step, index: i + 1, style: pendingStyle }, step.id)),
+      /* @__PURE__ */ jsx2(Text2, { children: "" }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "Failure policy: ",
+        failureDesc
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "green", children: "[Y] Confirm" }),
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "[M] Modify" }),
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "red", children: "[N] Cancel" })
+    ] }) })
+  ] });
+}
+function StepLine({ step, index, style }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text2, { ...style, children: [
+      index,
+      ". ",
+      step.description
+    ] }),
+    step.depends_on && step.depends_on.length > 0 && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "   \u2514\u2500 depends on: ",
+      step.depends_on.join(", ")
+    ] })
+  ] });
+}
+
+// src/tui/execution-view.tsx
+import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
+import { Spinner as Spinner2, useComponentTheme as useComponentTheme3 } from "@inkjs/ui";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ExecutionView({ workflow, stepProgress, output, onBack, onAbort }) {
+  const { styles } = useComponentTheme3("PlanView");
+  const titleStyle = styles?.title?.() ?? { color: "cyan", bold: true };
+  const isRunning = Array.from(stepProgress.values()).some((s) => s.status === "running");
+  useInput3((input, key) => {
+    if (isRunning && onAbort && input === "x") {
+      onAbort();
+      return;
+    }
+    if (!isRunning && onBack && (key.return || input === "q" || key.escape)) {
+      onBack();
+    }
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", children: [
+        /* @__PURE__ */ jsxs3(Text3, { ...titleStyle, children: [
+          "Workflow: ",
+          workflow.name
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          "Status: ",
+          isRunning ? "Running" : "Complete"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { children: "" }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, 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 ? ` (${formatDuration(progress.duration)})` : "";
+        return /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsxs3(Text3, { color: statusColor(status), children: [
+            icon,
+            " ",
+            i + 1,
+            ". ",
+            step.description,
+            durationText
+          ] }),
+          status === "running" && /* @__PURE__ */ jsx3(Spinner2, {})
+        ] }, step.id);
+      }),
+      output.length > 0 && /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2500\u2500 Live Output \u2500\u2500" }),
+        output.slice(-10).map((line, i) => /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: line }, i))
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: isRunning ? "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 "\u25CF";
+    case "failed":
+      return "\u2717";
+    case "skipped":
+      return "\u25CB";
+    default:
+      return " ";
+  }
+}
+function statusColor(status) {
+  switch (status) {
+    case "succeeded":
+      return "green";
+    case "running":
+      return "yellow";
+    case "failed":
+      return "red";
+    case "skipped":
+      return "gray";
+    default:
+      return "gray";
+  }
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+
+// src/tui/onboarding.tsx
+import { useState as useState2, useCallback, useMemo as useMemo2 } from "react";
+import { Box as Box4, Text as Text4, useStdout as useStdout2 } from "ink";
+import { TextInput, PasswordInput, ConfirmInput, Spinner as Spinner3, StatusMessage } from "@inkjs/ui";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "****" + key.slice(-4);
+}
+function Onboarding({ onComplete, issues }) {
+  const { stdout } = useStdout2();
+  const cols = stdout?.columns ?? 80;
+  const existing = useMemo2(() => loadExistingConfig(), []);
+  const initialStep = useMemo2(() => {
+    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] = useState2(initialStep);
+  const [state, setState] = useState2({
+    apiKey: existing.apiKey ?? "",
+    baseUrl: existing.baseUrl ?? "",
+    containerEnabled: existing.containerEnabled ?? false,
+    telegramEnabled: existing.telegramEnabled ?? false,
+    telegramToken: existing.telegramToken ?? "",
+    whatsappEnabled: existing.whatsappEnabled ?? false
+  });
+  const env = checkEnvironment();
+  const gotoApiKey = useCallback(() => {
+    setStep(existing.apiKey ? "api_key_existing" : "api_key");
+  }, [existing]);
+  const gotoBaseUrl = useCallback(() => {
+    if (!isDev) return;
+    setStep(existing.baseUrl ? "base_url_existing" : "base_url");
+  }, [existing]);
+  const gotoContainer = useCallback(() => {
+    if (!(env.docker && env.dockerRunning)) {
+      gotoTelegram();
+      return;
+    }
+    setStep(existing.containerEnabled !== void 0 ? "container_existing" : "container");
+  }, [env, existing]);
+  const gotoTelegram = useCallback(() => {
+    setStep(existing.telegramEnabled !== void 0 ? "telegram_existing" : "telegram");
+  }, [existing]);
+  const gotoTelegramToken = useCallback(() => {
+    setStep(existing.telegramToken ? "telegram_token_existing" : "telegram_token");
+  }, [existing]);
+  const gotoWhatsApp = useCallback(() => {
+    setStep(existing.whatsappEnabled !== void 0 ? "whatsapp_existing" : "whatsapp");
+  }, [existing]);
+  const afterValidation = useCallback(() => {
+    if (env.docker && env.dockerRunning) {
+      gotoContainer();
+    } else {
+      gotoTelegram();
+    }
+  }, [env, gotoContainer, gotoTelegram]);
+  const handleApiKeySubmit = useCallback((value) => {
+    const key = value.trim();
+    if (!key) return;
+    setState((s) => ({ ...s, apiKey: key }));
+    if (isDev) {
+      gotoBaseUrl();
+    } else {
+      setStep("validating");
+      doValidation(key, "");
+    }
+  }, [gotoBaseUrl]);
+  const handleBaseUrlSubmit = useCallback((value) => {
+    const url = value.trim();
+    setState((s) => ({ ...s, baseUrl: url }));
+    setStep("validating");
+    doValidation(state.apiKey, url);
+  }, [state.apiKey]);
+  const doValidation = useCallback(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 = useCallback(() => {
+    setState((s) => ({ ...s, containerEnabled: true }));
+    gotoTelegram();
+  }, [gotoTelegram]);
+  const handleContainerNo = useCallback(() => {
+    setState((s) => ({ ...s, containerEnabled: false }));
+    gotoTelegram();
+  }, [gotoTelegram]);
+  const handleTelegramYes = useCallback(() => {
+    setState((s) => ({ ...s, telegramEnabled: true }));
+    gotoTelegramToken();
+  }, [gotoTelegramToken]);
+  const handleTelegramNo = useCallback(() => {
+    setState((s) => ({ ...s, telegramEnabled: false }));
+    gotoWhatsApp();
+  }, [gotoWhatsApp]);
+  const handleTelegramTokenSubmit = useCallback((value) => {
+    setState((s) => ({ ...s, telegramToken: value.trim() }));
+    gotoWhatsApp();
+  }, [gotoWhatsApp]);
+  const finishWithWhatsApp = useCallback((enabled) => {
+    const next = { ...state, whatsappEnabled: enabled };
+    setState((s) => ({ ...s, whatsappEnabled: enabled }));
+    setStep("saving");
+    doSaveConfig(next);
+  }, [state]);
+  const handleWhatsAppYes = useCallback(() => finishWithWhatsApp(true), [finishWithWhatsApp]);
+  const handleWhatsAppNo = useCallback(() => finishWithWhatsApp(false), [finishWithWhatsApp]);
+  const doSaveConfig = useCallback((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__ */ jsxs4(Box4, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", flexGrow: 1, children }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: input })
+  ] });
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    step === "welcome" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(
+          TextInput,
+          {
+            placeholder: "Press Enter to continue...",
+            onSubmit: () => gotoApiKey()
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "Welcome to CueClaw" }),
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "First time? Let's set up CueClaw." }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2500".repeat(Math.max(0, cols - 2)) }),
+          /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+            /* @__PURE__ */ jsx4(Text4, { children: "Press " }),
+            /* @__PURE__ */ jsx4(Text4, { bold: true, color: "green", children: "Enter" }),
+            /* @__PURE__ */ jsx4(Text4, { children: " to begin setup" })
+          ] })
+        ]
+      }
+    ),
+    step === "api_key_existing" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(
+          ConfirmInput,
+          {
+            onConfirm: () => {
+              if (isDev) gotoBaseUrl();
+              else {
+                setStep("validating");
+                doValidation(state.apiKey, state.baseUrl);
+              }
+            },
+            onCancel: () => setStep("api_key")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 1: API Key" }),
+          /* @__PURE__ */ jsxs4(Text4, { children: [
+            "Found existing API key: ",
+            /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: maskKey(existing.apiKey) })
+          ] }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Keep this key?" })
+        ]
+      }
+    ),
+    step === "api_key" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: "green", children: "> " }),
+          /* @__PURE__ */ jsx4(PasswordInput, { placeholder: "sk-ant-...", onSubmit: handleApiKeySubmit })
+        ] }),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 1: API Key" }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Enter your Anthropic API key (or compatible provider key)" }),
+          state.validationError && /* @__PURE__ */ jsx4(Box4, { marginY: 1, children: /* @__PURE__ */ jsx4(StatusMessage, { variant: "error", children: state.validationError }) })
+        ]
+      }
+    ),
+    step === "base_url_existing" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(
+          ConfirmInput,
+          {
+            onConfirm: () => {
+              setStep("validating");
+              doValidation(state.apiKey, state.baseUrl);
+            },
+            onCancel: () => setStep("base_url")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 1b: Base URL" }),
+          /* @__PURE__ */ jsxs4(Text4, { children: [
+            "Found existing base URL: ",
+            /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: existing.baseUrl })
+          ] }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Keep this URL?" })
+        ]
+      }
+    ),
+    step === "base_url" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: "green", children: "> " }),
+          /* @__PURE__ */ jsx4(TextInput, { placeholder: "https://api.anthropic.com", onSubmit: handleBaseUrlSubmit })
+        ] }),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 1b: Base URL (optional)" }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Custom API base URL (leave empty for api.anthropic.com)" })
+        ]
+      }
+    ),
+    step === "validating" && /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx4(Spinner3, { label: "Validating API key..." }) }),
+    step === "container_existing" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(
+          ConfirmInput,
+          {
+            onConfirm: () => gotoTelegram(),
+            onCancel: () => setStep("container")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 2: Container Isolation" }),
+          /* @__PURE__ */ jsxs4(Text4, { children: [
+            "Container isolation is already ",
+            /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: existing.containerEnabled ? "enabled" : "disabled" }),
+            "."
+          ] }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Keep this setting?" })
+        ]
+      }
+    ),
+    step === "container" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(ConfirmInput, { onConfirm: handleContainerYes, onCancel: handleContainerNo }),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 2: Container Isolation" }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Docker detected. Enable container isolation for safer execution?" })
+        ]
+      }
+    ),
+    step === "telegram_existing" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(
+          ConfirmInput,
+          {
+            onConfirm: () => {
+              if (state.telegramEnabled) gotoTelegramToken();
+              else gotoWhatsApp();
+            },
+            onCancel: () => setStep("telegram")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 3: Telegram Bot" }),
+          /* @__PURE__ */ jsxs4(Text4, { children: [
+            "Telegram bot is already ",
+            /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: existing.telegramEnabled ? "enabled" : "disabled" }),
+            "."
+          ] }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Keep this setting?" })
+        ]
+      }
+    ),
+    step === "telegram" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(ConfirmInput, { onConfirm: handleTelegramYes, onCancel: handleTelegramNo }),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 3: Telegram Bot" }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Set up a Telegram bot for remote workflow management?" })
+        ]
+      }
+    ),
+    step === "telegram_token_existing" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(
+          ConfirmInput,
+          {
+            onConfirm: () => gotoWhatsApp(),
+            onCancel: () => setStep("telegram_token")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Telegram Bot Token" }),
+          /* @__PURE__ */ jsxs4(Text4, { children: [
+            "Found existing token: ",
+            /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: maskKey(existing.telegramToken) })
+          ] }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Keep this token?" })
+        ]
+      }
+    ),
+    step === "telegram_token" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: "green", children: "> " }),
+          /* @__PURE__ */ jsx4(PasswordInput, { placeholder: "123456:ABC...", onSubmit: handleTelegramTokenSubmit })
+        ] }),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Telegram Bot Token" }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Paste the token from @BotFather" })
+        ]
+      }
+    ),
+    step === "whatsapp_existing" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(
+          ConfirmInput,
+          {
+            onConfirm: () => finishWithWhatsApp(state.whatsappEnabled),
+            onCancel: () => setStep("whatsapp")
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 4: WhatsApp" }),
+          /* @__PURE__ */ jsxs4(Text4, { children: [
+            "WhatsApp is already ",
+            /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: existing.whatsappEnabled ? "enabled" : "disabled" }),
+            "."
+          ] }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Keep this setting?" })
+        ]
+      }
+    ),
+    step === "whatsapp" && /* @__PURE__ */ jsxs4(
+      StepLayout,
+      {
+        input: /* @__PURE__ */ jsx4(ConfirmInput, { onConfirm: handleWhatsAppYes, onCancel: handleWhatsAppNo }),
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Step 4: WhatsApp" }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Enable WhatsApp channel? (Requires QR scan on daemon start)" })
+        ]
+      }
+    ),
+    step === "saving" && /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx4(Spinner3, { label: "Saving configuration..." }) }),
+    step === "done" && /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx4(StatusMessage, { variant: "success", children: "Configuration saved!" }),
+      /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "API Key: ****",
+          state.apiKey.slice(-4)
+        ] }),
+        state.baseUrl && /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "Base URL: ",
+          state.baseUrl
+        ] }),
+        state.containerEnabled && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Container isolation: enabled" }),
+        state.telegramEnabled && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Telegram bot: configured" }),
+        state.whatsappEnabled && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "WhatsApp: enabled" })
+      ] }),
+      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { children: "Starting CueClaw..." }) })
+    ] })
+  ] });
+}
+
+// src/tui/renderers.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } 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__ */ jsx5(Text5, { dimColor: true, children: "No workflows found." });
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Box5, { width: 14, children: /* @__PURE__ */ jsx5(Text5, { bold: true, dimColor: true, children: "ID" }) }),
+      /* @__PURE__ */ jsx5(Box5, { width: 28, children: /* @__PURE__ */ jsx5(Text5, { bold: true, dimColor: true, children: "Name" }) }),
+      /* @__PURE__ */ jsx5(Box5, { width: 14, children: /* @__PURE__ */ jsx5(Text5, { bold: true, dimColor: true, children: "Phase" }) }),
+      /* @__PURE__ */ jsx5(Box5, { width: 16, children: /* @__PURE__ */ jsx5(Text5, { 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__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsx5(Box5, { width: 14, children: /* @__PURE__ */ jsx5(Text5, { children: wf.id.slice(0, 12) }) }),
+        /* @__PURE__ */ jsx5(Box5, { width: 28, children: /* @__PURE__ */ jsx5(Text5, { children: wf.name.slice(0, 26) }) }),
+        /* @__PURE__ */ jsx5(Box5, { width: 14, children: /* @__PURE__ */ jsx5(Text5, { color: phaseColor(wf.phase), children: wf.phase }) }),
+        /* @__PURE__ */ jsx5(Box5, { width: 16, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: trigger }) })
+      ] }, wf.id);
+    }),
+    /* @__PURE__ */ jsxs5(Text5, { 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__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: workflow.name }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "ID: ",
+      workflow.id
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Phase: ",
+      /* @__PURE__ */ jsx5(Text5, { color: phaseColor(workflow.phase), children: workflow.phase })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "Trigger: ",
+      trigger
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "Created: ",
+      workflow.created_at
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { children: "" }),
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Steps:" }),
+    workflow.steps.map((step, i) => {
+      const deps = step.depends_on.length > 0 ? ` (after: ${step.depends_on.join(", ")})` : "";
+      return /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "  ",
+        i + 1,
+        ". ",
+        step.id,
+        ": ",
+        step.description.slice(0, 60),
+        deps
+      ] }, step.id);
+    }),
+    latestRun && /* @__PURE__ */ jsxs5(Fragment, { children: [
+      /* @__PURE__ */ jsx5(Text5, { children: "" }),
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Latest Run:" }),
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "  Status: ",
+        latestRun.status
+      ] }),
+      latestRun.error && /* @__PURE__ */ jsxs5(Text5, { color: "red", children: [
+        "  Error: ",
+        latestRun.error
+      ] }),
+      stepRuns && stepRuns.length > 0 && /* @__PURE__ */ jsxs5(Fragment, { children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  Step results:" }),
+        stepRuns.map((sr) => /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+          "    ",
+          sr.step_id,
+          ": ",
+          sr.status,
+          sr.output_json ? ` \u2014 ${sr.output_json.slice(0, 50)}` : ""
+        ] }, sr.id))
+      ] })
+    ] })
+  ] });
+}
+
+// src/tui/daemon-bridge.ts
+async function initDaemonBridge(db, config, cwd, options) {
+  const status = getServiceStatus();
+  if (status === "running") {
+    logger.info("External daemon detected, TUI will operate as frontend only");
+    return {
+      triggerLoop: null,
+      router: null,
+      botChannels: [],
+      isExternal: true
+    };
+  }
+  const router = new MessageRouter(db, config, cwd);
+  const botChannels = [];
+  if (!options?.skipBots) {
+    await connectBotChannels(config, router, botChannels);
+  }
+  const triggerLoop = new TriggerLoop(db, router, cwd, 5);
+  triggerLoop.start();
+  router.start();
+  logger.info("In-process daemon bridge started");
+  return {
+    triggerLoop,
+    router,
+    botChannels,
+    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) {
+  if (config.telegram?.enabled && config.telegram.token) {
+    try {
+      const { TelegramChannel } = await import("./telegram-P6DBJ7WZ.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);
+      logger.info("Telegram channel started (in-process)");
+    } catch (err) {
+      logger.error({ err }, "Failed to start Telegram channel");
+    }
+  }
+  if (config.whatsapp?.enabled) {
+    try {
+      const { WhatsAppChannel } = await import("./whatsapp-HFMOFSFI.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);
+      logger.info("WhatsApp channel started (in-process)");
+    } catch (err) {
+      logger.error({ err }, "Failed to start WhatsApp channel");
+    }
+  }
+}
+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");
+}
+
+// src/planner-session.ts
+import { nanoid } from "nanoid";
+async function startPlannerSession(userMessage, config, callbacks) {
+  const session = {
+    id: `ps_${nanoid()}`,
+    messages: [{ role: "user", content: userMessage }],
+    status: "conversing",
+    workflow: null
+  };
+  const turn = await runPlannerTurn(session, config, callbacks);
+  return { session, turn };
+}
+async function continuePlannerSession(session, userMessage, config, callbacks) {
+  session.messages.push({ role: "user", content: userMessage });
+  const turn = await runPlannerTurn(session, config, callbacks);
+  return { session, turn };
+}
+function cancelPlannerSession(session) {
+  session.status = "cancelled";
+}
+async function runPlannerTurn(session, config, callbacks) {
+  const anthropic = createAnthropicClient(config);
+  const systemPrompt = buildPlannerSystemPrompt(config) + `
+
+## 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": {
+      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);
+    }
+    case "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":
+      return { type: "error", content: result.error };
+  }
+}
+
+// src/tui/app.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function appReducer(state, action) {
+  switch (action.type) {
+    case "SHOW_CHAT":
+      return { ...state, view: "chat" };
+    case "SHOW_ONBOARDING":
+      return { ...state, view: "onboarding" };
+    case "SHOW_PLAN":
+      return { ...state, view: "plan", workflow: action.workflow };
+    case "SHOW_EXECUTION":
+      return { ...state, view: "execution", workflow: action.workflow, stepProgress: /* @__PURE__ */ new Map(), executionOutput: [] };
+    case "SHOW_EXIT_PROMPT":
+      return { ...state, view: "exit_prompt" };
+    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 App({ cwd, skipOnboarding }) {
+  const { exit } = useApp();
+  const validation = useMemo3(() => validateConfig(), []);
+  const needsSetup = !skipOnboarding && !validation.valid;
+  const configIssues = validation.issues.filter((i) => i.severity === "error");
+  const [config, setConfig] = useState3(() => {
+    if (needsSetup) return null;
+    try {
+      return loadConfig();
+    } catch {
+      return null;
+    }
+  });
+  const db = useMemo3(() => initDb(), []);
+  const bridgeRef = useRef2(null);
+  const abortRef = useRef2(null);
+  const abortMapRef = useRef2(/* @__PURE__ */ new Map());
+  const [isExecuting, setIsExecuting] = useState3(false);
+  const [daemonStatus, setDaemonStatus] = useState3("none");
+  const plannerSessionRef = useRef2(null);
+  useEffect2(() => {
+    return onLogLine((line) => {
+      dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: line } });
+    });
+  }, []);
+  const initialState = {
+    view: needsSetup ? "onboarding" : "chat",
+    messages: [],
+    workflow: null,
+    isGenerating: false,
+    stepProgress: /* @__PURE__ */ new Map(),
+    executionOutput: [],
+    streamingText: ""
+  };
+  const [state, dispatch] = useReducer2(appReducer, initialState);
+  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: { role: "system", text: "Starting daemon..." } });
+    initDaemonBridge(db, config, cwd, { skipBots: true }).then((bridge) => {
+      if (cancelled) {
+        stopDaemonBridge(bridge);
+        return;
+      }
+      bridgeRef.current = bridge;
+      setDaemonStatus(bridge.isExternal ? "external" : "running");
+      dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: bridge.isExternal ? "Background service detected." : "Daemon started." } });
+      if (!bridge.isExternal && hasConfiguredBots) {
+        const botList = [];
+        if (config.telegram?.enabled && config.telegram?.token) botList.push("Telegram");
+        if (config.whatsapp?.enabled) botList.push("WhatsApp");
+        dispatch({
+          type: "ADD_MESSAGE",
+          message: { role: "assistant", text: `${botList.join(" and ")} bot${botList.length > 1 ? "s are" : " is"} configured. Type /bot start to launch.` }
+        });
+      }
+    }).catch((err) => {
+      logger.error({ err }, "Failed to start daemon bridge");
+      setDaemonStatus("none");
+      dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: "Failed to start daemon." } });
+    });
+    return () => {
+      cancelled = true;
+      if (bridgeRef.current) {
+        stopDaemonBridge(bridgeRef.current);
+        bridgeRef.current = null;
+      }
+    };
+  }, [config, db, cwd]);
+  useInput4((input, key) => {
+    if (input === "c" && key.ctrl) {
+      const bridge = bridgeRef.current;
+      const hasRunning = isExecuting || bridge && !bridge.isExternal;
+      if (hasRunning && state.view !== "exit_prompt") {
+        dispatch({ type: "SHOW_EXIT_PROMPT" });
+        return;
+      }
+      if (bridge) {
+        stopDaemonBridge(bridge).finally(() => {
+          exit();
+          process.exit(0);
+        });
+      } else {
+        exit();
+        process.exit(0);
+      }
+    }
+    if (state.view === "onboarding" || state.view === "exit_prompt") return;
+    if (input === "d" && key.ctrl) {
+      const workflows = listWorkflows(db);
+      dispatch({
+        type: "ADD_MESSAGE",
+        message: {
+          role: "assistant",
+          content: React2.createElement(WorkflowTable, { workflows })
+        }
+      });
+    }
+  });
+  const commandCtx = useMemo3(() => ({
+    db,
+    config,
+    cwd,
+    bridge: bridgeRef.current,
+    addMessage: (msg) => dispatch({ type: "ADD_MESSAGE", message: msg }),
+    clearMessages: () => dispatch({ type: "SET_MESSAGES", messages: [] }),
+    setConfig
+  }), [db, config, cwd]);
+  const handleOnboardingComplete = useCallback2((newConfig) => {
+    setConfig(newConfig);
+    dispatch({ type: "SHOW_CHAT" });
+  }, []);
+  const handleChatSubmit = useCallback2(async (text) => {
+    if (!config) return;
+    const parsed = parseSlashCommand(text);
+    if (parsed) {
+      dispatch({ type: "ADD_MESSAGE", message: { role: "user", text } });
+      if (parsed.name === "cancel") {
+        if (plannerSessionRef.current) {
+          cancelPlannerSession(plannerSessionRef.current);
+          plannerSessionRef.current = null;
+        }
+        dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: "Conversation cancelled." } });
+        return;
+      }
+      if (parsed.name === "new" && !parsed.args) {
+        dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: "Usage: /new <workflow description>" } });
+        return;
+      }
+      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-UU4T5IEN.js");
+          const workflow = await generatePlan(parsed.args, config);
+          dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: `Generated plan: "${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: { role: "assistant", text: `Error: ${msg}` } });
+          dispatch({ type: "SET_GENERATING", value: false });
+        }
+        return;
+      }
+      if (parsed.name === "list" || parsed.name === "ls") {
+        const workflows = listWorkflows(db);
+        dispatch({
+          type: "ADD_MESSAGE",
+          message: {
+            role: "assistant",
+            content: React2.createElement(WorkflowTable, { workflows })
+          }
+        });
+        return;
+      }
+      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: {
+              role: "assistant",
+              content: React2.createElement(WorkflowDetail, { workflow: wf, latestRun, stepRuns })
+            }
+          });
+          return;
+        }
+        dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: `Workflow not found: ${parsed.args}` } });
+        return;
+      }
+      if (parsed.name === "clear" || parsed.name === "cls") {
+        dispatch({ type: "SET_MESSAGES", messages: [] });
+        return;
+      }
+      if (parsed.name === "bot" && parsed.args.trim().toLowerCase() === "start") {
+        const bridge = bridgeRef.current;
+        if (bridge && config) {
+          dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: "Starting bot channels..." } });
+          try {
+            await startBotChannels(bridge, config);
+            dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: "Bot channels started." } });
+          } catch (err) {
+            dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: `Failed to start bots: ${err instanceof Error ? err.message : String(err)}` } });
+          }
+        } else {
+          dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: "Daemon not running. Cannot start bots." } });
+        }
+        return;
+      }
+      if (parsed.name === "setup") {
+        dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: "Starting setup wizard..." } });
+        setConfig(null);
+        dispatch({ type: "SET_MESSAGES", messages: [] });
+        dispatch({ type: "SHOW_ONBOARDING" });
+        return;
+      }
+      const cmd = findCommand(parsed.name);
+      if (cmd) {
+        commandCtx.bridge = bridgeRef.current;
+        commandCtx.config = config;
+        await cmd.execute(parsed.args, commandCtx);
+      } else {
+        dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: `Unknown command: /${parsed.name}. Type /help for available commands.` } });
+      }
+      return;
+    }
+    dispatch({ type: "ADD_MESSAGE", message: { role: "user", text } });
+    dispatch({ type: "SET_GENERATING", value: true });
+    dispatch({ type: "SET_STREAMING_TEXT", text: "" });
+    try {
+      let result;
+      if (plannerSessionRef.current && plannerSessionRef.current.status === "conversing") {
+        result = await continuePlannerSession(
+          plannerSessionRef.current,
+          text,
+          config,
+          {
+            onToken: (token) => {
+              dispatch({ type: "SET_STREAMING_TEXT", text: (state.streamingText || "") + token });
+            }
+          }
+        );
+      } else {
+        result = await startPlannerSession(
+          text,
+          config,
+          {
+            onToken: (token) => {
+              dispatch({ type: "SET_STREAMING_TEXT", text: (state.streamingText || "") + token });
+            }
+          }
+        );
+      }
+      plannerSessionRef.current = result.session;
+      dispatch({ type: "SET_STREAMING_TEXT", text: "" });
+      switch (result.turn.type) {
+        case "question":
+          dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: result.turn.content } });
+          dispatch({ type: "SET_GENERATING", value: false });
+          break;
+        case "plan":
+          if (result.turn.workflow) {
+            dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: `Generated plan: "${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: { role: "assistant", text: result.turn.content } });
+          dispatch({ type: "SET_GENERATING", value: false });
+          break;
+        case "error":
+          dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", 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: { role: "assistant", 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, db, commandCtx, state.streamingText]);
+  const handleConfirm = useCallback2(async () => {
+    if (!state.workflow) return;
+    const confirmed = confirmPlan(state.workflow);
+    try {
+      insertWorkflow(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);
+    plannerSessionRef.current = null;
+    dispatch({ type: "SHOW_EXECUTION", workflow: confirmed });
+    try {
+      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 });
+            }
+          }
+        }
+      });
+      const trigger = confirmed.trigger;
+      if (trigger.type === "poll") {
+        dispatch({ type: "ADD_MESSAGE", message: { role: "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: { role: "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: { role: "system", text: "Workflow execution completed." } });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      dispatch({ type: "ADD_MESSAGE", message: { role: "system", text: `Execution failed: ${msg}` } });
+      logger.error({ err }, "Workflow execution failed");
+    } finally {
+      abortMapRef.current.delete(confirmed.id);
+      setIsExecuting(abortMapRef.current.size > 0);
+    }
+  }, [state.workflow, db, cwd]);
+  const handleModify = useCallback2(() => {
+    dispatch({ type: "SHOW_CHAT" });
+    dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: "Describe your modifications:" } });
+  }, []);
+  const handleCancel = useCallback2(() => {
+    if (state.workflow) {
+      rejectPlan(state.workflow);
+    }
+    plannerSessionRef.current = null;
+    dispatch({ type: "SHOW_CHAT" });
+    dispatch({ type: "ADD_MESSAGE", message: { role: "assistant", text: "Plan cancelled." } });
+  }, [state.workflow]);
+  const handleExecutionAbort = useCallback2(() => {
+    abortRef.current?.abort();
+  }, []);
+  const handleExecutionBack = useCallback2(() => {
+    dispatch({ type: "SHOW_CHAT" });
+  }, []);
+  const handleExitInstall = useCallback2(async () => {
+    try {
+      const { installService } = await import("./service-VTUYSAAZ.js");
+      const result = installService();
+      if (result.success) {
+        logger.info("System service installed");
+      }
+    } catch (err) {
+      logger.error({ err }, "Failed to install service");
+    }
+    const bridge = bridgeRef.current;
+    if (bridge) await stopDaemonBridge(bridge);
+    exit();
+    process.exit(0);
+  }, [exit]);
+  const handleExitNoInstall = useCallback2(async () => {
+    for (const controller of abortMapRef.current.values()) {
+      controller.abort();
+    }
+    const bridge = bridgeRef.current;
+    if (bridge) await stopDaemonBridge(bridge);
+    exit();
+    process.exit(0);
+  }, [exit]);
+  const { stdout } = useStdout3();
+  const footerExtra = daemonStatus === "external" ? " | Background service detected" : daemonStatus === "running" ? " | Daemon active" : "";
+  const footerHints = plannerSessionRef.current?.status === "conversing" ? "Enter send \xB7 /cancel abort \xB7 /help commands" : void 0;
+  const displayPath = cwd ? cwd.replace(process.env["HOME"] ?? "", "~") : "";
+  const versionLabel = appVersion === "dev" ? "dev" : `v${appVersion}`;
+  const rows = stdout?.rows ?? 24;
+  return /* @__PURE__ */ jsx6(ThemeProvider, { theme: cueclawTheme, children: /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx6(Static, { items: state.view !== "onboarding" ? ["banner"] : [], children: (item) => /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "cyan", bold: true, children: "CueClaw" }),
+      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        versionLabel,
+        " \xB7 ",
+        displayPath
+      ] })
+    ] }, item) }),
+    state.view === "onboarding" && /* @__PURE__ */ jsx6(Onboarding, { onComplete: handleOnboardingComplete, issues: configIssues }),
+    state.view === "chat" && /* @__PURE__ */ jsx6(
+      Chat,
+      {
+        messages: state.messages,
+        isGenerating: state.isGenerating,
+        onSubmit: handleChatSubmit,
+        footerExtra,
+        footerHints,
+        streamingText: state.streamingText || void 0
+      }
+    ),
+    state.view === "plan" && state.workflow && /* @__PURE__ */ jsx6(
+      PlanView,
+      {
+        workflow: state.workflow,
+        onConfirm: handleConfirm,
+        onModify: handleModify,
+        onCancel: handleCancel
+      }
+    ),
+    state.view === "execution" && state.workflow && /* @__PURE__ */ jsx6(
+      ExecutionView,
+      {
+        workflow: state.workflow,
+        stepProgress: state.stepProgress,
+        output: state.executionOutput,
+        onBack: handleExecutionBack,
+        onAbort: handleExecutionAbort
+      }
+    ),
+    state.view === "exit_prompt" && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", flexGrow: 1, children: [
+        isExecuting && /* @__PURE__ */ jsx6(Text6, { bold: true, color: "yellow", children: "A workflow is currently running. It will be cancelled if you exit." }),
+        bridgeRef.current && !bridgeRef.current.isExternal ? /* @__PURE__ */ jsxs6(Fragment2, { children: [
+          /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Install as background service?" }),
+          /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "This lets poll/cron workflows keep running after you exit." })
+        ] }) : /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Are you sure you want to exit?" })
+      ] }),
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: bridgeRef.current && !bridgeRef.current.isExternal ? /* @__PURE__ */ jsx6(ConfirmInput2, { onConfirm: handleExitInstall, onCancel: handleExitNoInstall }) : /* @__PURE__ */ jsx6(
+        ConfirmInput2,
+        {
+          onConfirm: handleExitNoInstall,
+          onCancel: () => dispatch({ type: "SHOW_CHAT" })
+        }
+      ) })
+    ] })
+  ] }) });
+}
+export {
+  App
+};