workermill 0.1.8 → 0.2.0

package/dist/index.js

@@ -1,28 +1,18 @@
 #!/usr/bin/env node
-import {
-  exitTerminal,
-  initTerminal,
-  setStatusBar,
-  showStatusBar
-} from "./chunk-LVCJZJJH.js";
 import {
   CostTracker,
-  PermissionManager,
+  buildOllamaOptions,
   createModel,
   createToolDefinitions,
   getProviderForPersona,
   killActiveProcess,
   loadConfig,
-  printError,
-  printHeader,
-  printStatusBar,
-  printToolCall,
-  printToolResult,
   saveConfig
-} from "./chunk-3KIFXIBC.js";
-import "./chunk-2NTK7H4W.js";
+} from "./chunk-VC6VNVEY.js";
 
 // src/index.ts
+import React5 from "react";
+import { render } from "ink";
 import { Command } from "commander";
 
 // src/setup.js
@@ -32,8 +22,8 @@ import chalk from "chalk";
 var PROVIDERS = [
   { name: "ollama", display: "Ollama (local, no API key needed)", needsKey: false, defaultModel: "qwen3-coder:30b" },
   { name: "anthropic", display: "Anthropic (Claude)", needsKey: true, defaultModel: "claude-sonnet-4-6", envVar: "ANTHROPIC_API_KEY" },
-  { name: "openai", display: "OpenAI (GPT)", needsKey: true, defaultModel: "gpt-4o", envVar: "OPENAI_API_KEY" },
-  { name: "google", display: "Google (Gemini)", needsKey: true, defaultModel: "gemini-2.5-pro", envVar: "GOOGLE_API_KEY" }
+  { name: "openai", display: "OpenAI (GPT)", needsKey: true, defaultModel: "gpt-5.4", envVar: "OPENAI_API_KEY" },
+  { name: "google", display: "Google (Gemini)", needsKey: true, defaultModel: "gemini-3.1-pro", envVar: "GOOGLE_API_KEY" }
 ];
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
@@ -97,9 +87,11 @@ async function runSetup() {
         continue;
       }
     }
+    providerConfig.contextLength = 65536;
     if (connectedHost) {
       providerConfig.host = connectedHost;
       console.log(chalk.green(`  \u2713 Connected to Ollama at ${connectedHost}`));
+      console.log(chalk.dim(`  Context window: ${providerConfig.contextLength.toLocaleString()} tokens`));
       if (models.length > 0) {
         console.log(chalk.dim(`  Available models: ${models.map((m) => m.name).join(", ")}`));
       }
@@ -126,80 +118,18 @@ async function runSetup() {
   return config;
 }
 
-// src/agent.js
-import readline2 from "readline";
-import fs4 from "fs";
-import pathModule from "path";
-import chalk3 from "chalk";
-import ora2 from "ora";
-import { execSync as execSync3 } from "child_process";
-import { streamText, stepCountIs } from "ai";
-
-// src/commands.js
-import chalk2 from "chalk";
-import ora from "ora";
+// src/ui/Root.tsx
+import { useState as useState5, useCallback as useCallback3, useRef as useRef3 } from "react";
+import { useApp as useApp2 } from "ink";
+import { execSync as execSync2 } from "child_process";
 import fs2 from "fs";
-import os from "os";
 import path2 from "path";
-import { execSync as execSync2 } from "child_process";
+import os from "os";
 
-// src/compaction.js
-import { generateText } from "ai";
-var CONTEXT_LIMITS = {
-  // Anthropic
-  "claude-opus": 2e5,
-  "claude-sonnet": 2e5,
-  "claude-haiku": 2e5,
-  // OpenAI
-  "gpt-4o": 128e3,
-  "gpt-4o-mini": 128e3,
-  "o3": 2e5,
-  "o3-mini": 128e3,
-  // Google
-  "gemini-2.5-pro": 1e6,
-  "gemini-2.5-flash": 1e6,
-  // Ollama (conservative default)
-  "default": 32e3
-};
-function getContextLimit(model) {
-  for (const [prefix, limit] of Object.entries(CONTEXT_LIMITS)) {
-    if (model.includes(prefix))
-      return limit;
-  }
-  return CONTEXT_LIMITS["default"];
-}
-function shouldCompact(totalTokens, model) {
-  const limit = getContextLimit(model);
-  if (totalTokens >= limit * 0.95)
-    return "hard";
-  if (totalTokens >= limit * 0.8)
-    return "soft";
-  return "none";
-}
-async function compactMessages(model, messages, mode) {
-  if (messages.length <= 4)
-    return messages;
-  const keepCount = mode === "hard" ? 2 : 4;
-  const toCompact = messages.slice(0, -keepCount);
-  const toKeep = messages.slice(-keepCount);
-  if (toCompact.length === 0)
-    return messages;
-  const summaryText = toCompact.map((m) => `${m.role}: ${m.content.slice(0, 500)}`).join("\n\n");
-  try {
-    const result = await generateText({
-      model,
-      system: "Summarize this conversation history concisely. Focus on: what was discussed, what decisions were made, what files were modified, and what the current state of work is. Be brief but preserve all important context.",
-      prompt: summaryText
-    });
-    return [
-      { role: "assistant", content: `[Conversation summary]
-${result.text}` },
-      ...toKeep
-    ];
-  } catch {
-    return toKeep;
-  }
-}
+// src/ui/useAgent.ts
+import { useState, useCallback, useRef, useEffect } from "react";
+import { streamText, stepCountIs } from "ai";
+import crypto2 from "crypto";
 
 // src/session.js
 import fs from "fs";
@@ -271,270 +201,1369 @@ function listSessions(max = 20) {
     return [];
   }
 }
-function loadSessionById(id) {
-  ensureSessionsDir();
-  try {
-    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
-    if (fs.existsSync(filePath)) {
-      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    }
-    const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.startsWith(id));
-    if (files.length === 1) {
-      return JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, files[0]), "utf-8"));
-    }
-  } catch {
+
+// src/compaction.js
+import { generateText } from "ai";
+var CONTEXT_LIMITS = {
+  // Anthropic (Claude 4.5/4.6)
+  "claude-opus": 2e5,
+  "claude-sonnet": 2e5,
+  "claude-haiku": 2e5,
+  // OpenAI (GPT-5.x)
+  "gpt-5.4": 4e5,
+  "gpt-5.3": 4e5,
+  "gpt-5.2": 2e5,
+  "gpt-5.4-mini": 2e5,
+  // Google (Gemini 3.x)
+  "gemini-3.1": 1e6,
+  "gemini-3.0": 1e6,
+  "gemini-2.5": 1e6,
+  // Ollama — uses configured contextLength, this is just fallback
+  "default": 65536
+};
+function getContextLimit(model) {
+  for (const [prefix, limit] of Object.entries(CONTEXT_LIMITS)) {
+    if (model.includes(prefix))
+      return limit;
   }
-  return null;
+  return CONTEXT_LIMITS["default"];
 }
-function deleteSession(id) {
-  ensureSessionsDir();
+function shouldCompact(totalTokens, model, configuredContextLength) {
+  const limit = configuredContextLength || getContextLimit(model);
+  if (totalTokens >= limit * 0.95)
+    return "hard";
+  if (totalTokens >= limit * 0.8)
+    return "soft";
+  return "none";
+}
+async function compactMessages(model, messages, mode) {
+  if (messages.length <= 4)
+    return messages;
+  const keepCount = mode === "hard" ? 2 : 4;
+  const toCompact = messages.slice(0, -keepCount);
+  const toKeep = messages.slice(-keepCount);
+  if (toCompact.length === 0)
+    return messages;
+  const summaryText = toCompact.map((m) => `${m.role}: ${m.content.slice(0, 500)}`).join("\n\n");
   try {
-    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath);
-      return true;
-    }
+    const result = await generateText({
+      model,
+      system: "Summarize this conversation history concisely. Focus on: what was discussed, what decisions were made, what files were modified, and what the current state of work is. Be brief but preserve all important context.",
+      prompt: summaryText
+    });
+    return [
+      { role: "assistant", content: `[Conversation summary]
+${result.text}` },
+      ...toKeep
+    ];
   } catch {
+    return toKeep;
   }
-  return false;
-}
-
-// src/commands.js
-async function handleCommand(cmd, ctx) {
-  const parts = cmd.slice(1).split(" ");
-  const command = parts[0];
-  switch (command) {
-    case "help":
-      console.log();
-      console.log(chalk2.bold("  Commands:"));
-      console.log(chalk2.dim("  /help      ") + "Show this help");
-      console.log(chalk2.dim("  /clear     ") + "Clear conversation history");
-      console.log(chalk2.dim("  /compact   ") + "Manually compact conversation");
-      console.log(chalk2.dim("  /status    ") + "Show session status");
-      console.log(chalk2.dim("  /model     ") + "Show current model");
-      console.log(chalk2.dim("  /cost      ") + "Show token cost breakdown");
-      console.log(chalk2.dim("  /git       ") + "Show git status");
-      console.log(chalk2.dim("  /sessions  ") + "List/switch sessions");
-      console.log(chalk2.dim("  /editor    ") + "Open $EDITOR for input");
-      console.log(chalk2.dim("  /plan      ") + "Toggle plan mode (read-only)");
-      console.log(chalk2.dim("  /quit      ") + "Exit");
-      console.log();
-      console.log(chalk2.dim("  Prefix ! for bash: ") + chalk2.white("!git status"));
-      console.log(chalk2.dim("  Multiline: ``` to start/end, or \\ at end of line"));
-      console.log();
-      break;
-    case "clear":
-      ctx.session.messages = [];
-      saveSession(ctx.session);
-      console.log(chalk2.green("\n  Conversation cleared\n"));
-      break;
-    case "compact": {
-      const { provider, model: modelName, host } = getProviderForPersona(ctx.config);
-      const model = createModel(provider, modelName, host);
-      const plainMessages = ctx.session.messages.map((m) => ({ role: m.role, content: m.content }));
-      if (plainMessages.length <= 4) {
-        console.log(chalk2.dim("\n  Not enough messages to compact.\n"));
-        break;
+}
+
+// src/ui/useAgent.ts
+var DANGEROUS_PATTERNS = [
+  {
+    pattern: /rm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i,
+    label: "recursive/forced delete"
+  },
+  { pattern: /git\s+reset\s+--hard/i, label: "hard reset" },
+  { pattern: /git\s+push\s+.*--force/i, label: "force push" },
+  { pattern: /git\s+clean\s+-[a-z]*f/i, label: "git clean" },
+  { pattern: /drop\s+table/i, label: "drop table" },
+  { pattern: /truncate\s+/i, label: "truncate" },
+  { pattern: /chmod\s+777/i, label: "chmod 777" }
+];
+var READ_TOOLS = /* @__PURE__ */ new Set([
+  "read_file",
+  "glob",
+  "grep",
+  "ls",
+  "sub_agent"
+]);
+function buildSystemPrompt(workingDir) {
+  return `You are WorkerMill, an AI coding agent running in the user's terminal.
+
+Working directory: ${workingDir}
+
+## How to behave
+
+- Be concise. Short replies unless the task demands detail.
+- If the user says hello or asks a casual question, respond briefly. Do NOT explore the codebase, read files, or use tools unless the user asks you to do something specific.
+- Only use tools when you have a concrete task. "Hello" is not a task.
+- When you DO have a task, read relevant files first, make changes, and verify they work.
+- Prefer editing existing files over creating new ones.
+- Run tests after changes when test infrastructure exists.
+
+## Communication style
+
+Direct. No filler. No "Perfect!", "Great!", "Sure!". Lead with substance.
+Do NOT repeat yourself across steps. Each response adds new information only.
+Do NOT list your capabilities unless asked. Do NOT offer menus of options unprompted.
+
+## Rules
+
+- NEVER start long-running processes (dev servers, watch modes, etc.)
+- NEVER run interactive commands that wait for user input
+- Only run commands that complete and exit
+- If the task specifies a dependency version, use that version. Trust the spec.
+
+## Learnings
+
+When you discover something non-obvious about this codebase, emit:
+::learning::The test suite requires DATABASE_URL or tests silently skip`;
+}
+function useAgent(options) {
+  const modelRef = useRef(null);
+  const toolsRef = useRef(null);
+  const aiProviderRef = useRef(options.provider);
+  const [messages, setMessages] = useState([]);
+  const [streamingText, setStreamingText] = useState("");
+  const [streamingToolCalls, setStreamingToolCalls] = useState(
+    []
+  );
+  const [status, setStatus] = useState("idle");
+  const [permissionRequest, setPermissionRequest] = useState(null);
+  const [tokens, setTokens] = useState(0);
+  const [cost, setCost] = useState(0);
+  const [trustAll, setTrustAllState] = useState(options.trustAll);
+  const [planMode, setPlanModeState] = useState(options.planMode);
+  const abortRef = useRef(null);
+  const sessionRef = useRef(null);
+  const costTrackerRef = useRef(new CostTracker());
+  const sessionAllowRef = useRef(/* @__PURE__ */ new Set());
+  const trustAllRef = useRef(options.trustAll);
+  const planModeRef = useRef(options.planMode);
+  const workingDirRef = useRef(process.cwd());
+  const initDoneRef = useRef(false);
+  trustAllRef.current = trustAll;
+  planModeRef.current = planMode;
+  if (!initDoneRef.current) {
+    initDoneRef.current = true;
+    if (options.apiKey) {
+      const envMap = {
+        anthropic: "ANTHROPIC_API_KEY",
+        openai: "OPENAI_API_KEY",
+        google: "GOOGLE_API_KEY"
+      };
+      const envVar = envMap[options.provider];
+      if (envVar && !process.env[envVar]) {
+        process.env[envVar] = options.apiKey;
       }
-      const spinner = ora({ stream: process.stdout, text: "Compacting conversation...", prefixText: "  " }).start();
-      const compacted = await compactMessages(model, plainMessages, "soft");
-      ctx.session.messages = compacted.map((m) => ({
-        role: m.role,
-        content: m.content,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
-      saveSession(ctx.session);
-      spinner.succeed(`Compacted to ${ctx.session.messages.length} messages`);
-      console.log();
-      break;
     }
-    case "status":
-      console.log();
-      console.log(chalk2.bold("  Session Status:"));
-      console.log(chalk2.dim("  Messages: ") + ctx.session.messages.length);
-      console.log(chalk2.dim("  Tokens: ") + ctx.session.totalTokens.toLocaleString());
-      console.log(chalk2.dim("  Cost: ") + `$${ctx.costTracker.getTotalCost().toFixed(4)}`);
-      console.log(chalk2.dim("  Mode: ") + (ctx.planMode ? chalk2.cyan("PLAN (read-only)") : "normal"));
-      console.log();
-      break;
-    case "model": {
-      const { provider, model } = getProviderForPersona(ctx.config);
-      console.log(chalk2.dim(`
-  ${provider}/${model}
-`));
-      break;
+    aiProviderRef.current = options.provider;
+    modelRef.current = createModel(
+      aiProviderRef.current,
+      options.model,
+      options.host,
+      options.contextLength
+    );
+    toolsRef.current = createToolDefinitions(
+      workingDirRef.current,
+      modelRef.current,
+      options.sandboxed
+    );
+    if (options.resume) {
+      const loaded = loadLatestSession();
+      if (loaded) {
+        sessionRef.current = loaded;
+        const restored = loaded.messages.map((m) => ({
+          id: crypto2.randomUUID(),
+          role: m.role,
+          content: m.content,
+          timestamp: m.timestamp
+        }));
+        sessionRef.current._restored = restored;
+      } else {
+        sessionRef.current = createSession(options.provider, options.model);
+      }
+    } else {
+      sessionRef.current = createSession(options.provider, options.model);
     }
-    case "cost":
-      console.log(chalk2.dim(`
-  ${ctx.costTracker.getSummary()}
-`));
-      break;
-    case "git": {
-      try {
-        const status = execSync2("git status --short", { cwd: ctx.workingDir, encoding: "utf-8" });
-        const branch = execSync2("git branch --show-current", { cwd: ctx.workingDir, encoding: "utf-8" }).trim();
-        console.log(chalk2.dim(`
-  Branch: `) + chalk2.white(branch));
-        if (status.trim()) {
-          console.log(chalk2.dim("  Changes:"));
-          for (const line of status.trim().split("\n").slice(0, 15)) {
-            console.log(chalk2.dim(`    ${line}`));
+  }
+  useEffect(() => {
+    const s = sessionRef.current;
+    if (s._restored) {
+      setMessages(s._restored);
+      delete s._restored;
+    }
+  }, []);
+  function detectDanger(toolName, toolInput) {
+    if (toolName !== "bash") return null;
+    const command = String(toolInput.command ?? "");
+    for (const { pattern, label } of DANGEROUS_PATTERNS) {
+      if (pattern.test(command)) return label;
+    }
+    return null;
+  }
+  const checkPermission = useCallback(
+    (toolName, toolInput) => {
+      const dangerLabel = detectDanger(toolName, toolInput);
+      if (dangerLabel) {
+        return new Promise((resolve) => {
+          setPermissionRequest({
+            toolName,
+            toolInput,
+            isDangerous: true,
+            dangerLabel,
+            resolve: (allowed, mode) => {
+              setPermissionRequest(null);
+              resolve({ allowed, mode });
+            }
+          });
+        });
+      }
+      if (trustAllRef.current) {
+        return Promise.resolve({ allowed: true });
+      }
+      if (READ_TOOLS.has(toolName)) {
+        return Promise.resolve({ allowed: true });
+      }
+      if (sessionAllowRef.current.has(toolName)) {
+        return Promise.resolve({ allowed: true });
+      }
+      return new Promise((resolve) => {
+        setPermissionRequest({
+          toolName,
+          toolInput,
+          isDangerous: false,
+          resolve: (allowed, mode) => {
+            setPermissionRequest(null);
+            resolve({ allowed, mode });
+          }
+        });
+      });
+    },
+    []
+    // trustAllRef and sessionAllowRef are refs -- stable across renders.
+  );
+  const buildPermissionedTools = useCallback(() => {
+    const raw = toolsRef.current;
+    if (!raw) return {};
+    const wrapped = {};
+    for (const [name, toolDef] of Object.entries(raw)) {
+      const td = toolDef;
+      wrapped[name] = {
+        ...td,
+        execute: async (input) => {
+          const callId = crypto2.randomUUID();
+          const info = {
+            id: callId,
+            name,
+            input,
+            status: "pending"
+          };
+          setStreamingToolCalls((prev) => [...prev, info]);
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: `tc-${callId}`,
+              role: "assistant",
+              content: "",
+              toolCalls: [{ ...info, status: "running" }],
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          ]);
+          setStatus("permission");
+          const { allowed, mode } = await checkPermission(name, input);
+          if (mode === "trust") {
+            setTrustAllState(true);
+          } else if (mode === "always") {
+            sessionAllowRef.current.add(name);
+          }
+          if (!allowed) {
+            setStreamingToolCalls(
+              (prev) => prev.map(
+                (tc) => tc.id === callId ? { ...tc, status: "denied" } : tc
+              )
+            );
+            setStatus("streaming");
+            return "Tool execution denied by user.";
+          }
+          setStreamingToolCalls(
+            (prev) => prev.map(
+              (tc) => tc.id === callId ? { ...tc, status: "running" } : tc
+            )
+          );
+          setStatus("tool_running");
+          try {
+            const result = await td.execute(input);
+            const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+            setStreamingToolCalls(
+              (prev) => prev.map(
+                (tc) => tc.id === callId ? { ...tc, status: "done", result: resultStr } : tc
+              )
+            );
+            setStatus("streaming");
+            return result;
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            setStreamingToolCalls(
+              (prev) => prev.map(
+                (tc) => tc.id === callId ? {
+                  ...tc,
+                  status: "done",
+                  result: `Error: ${errMsg}`
+                } : tc
+              )
+            );
+            setStatus("streaming");
+            throw err;
           }
-        } else {
-          console.log(chalk2.dim("  Working tree clean"));
         }
-        console.log();
-      } catch {
-        console.log(chalk2.dim("\n  Not a git repository.\n"));
+      };
+    }
+    return wrapped;
+  }, [checkPermission]);
+  const getActiveTools = useCallback(() => {
+    const all = buildPermissionedTools();
+    if (!planModeRef.current) return all;
+    const filtered = {};
+    for (const [name, def] of Object.entries(all)) {
+      if (READ_TOOLS.has(name)) {
+        filtered[name] = def;
       }
-      break;
     }
-    case "sessions": {
-      const args = parts.slice(1).join(" ").trim();
-      if (args.startsWith("delete ")) {
-        const deleteId = args.slice(7).trim();
-        if (deleteSession(deleteId)) {
-          console.log(chalk2.green(`
-  Session ${deleteId.slice(0, 8)} deleted.
-`));
-        } else {
-          console.log(chalk2.red(`
-  Session not found: ${deleteId}
-`));
+    return filtered;
+  }, [buildPermissionedTools]);
+  const submit = useCallback(
+    (input) => {
+      void (async () => {
+        const session = sessionRef.current;
+        addMessage(session, "user", input);
+        if (!session.name) {
+          session.name = input.slice(0, 50).replace(/\n/g, " ");
         }
-        break;
-      }
-      if (args) {
-        const targetId = args;
-        let loaded = loadSessionById(targetId);
-        if (!loaded) {
-          const sessions2 = listSessions();
-          const idx = parseInt(targetId, 10) - 1;
-          if (idx >= 0 && idx < sessions2.length) {
-            loaded = loadSessionById(sessions2[idx].id);
+        const userMsg = {
+          id: crypto2.randomUUID(),
+          role: "user",
+          content: input,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        setMessages((prev) => [...prev, userMsg]);
+        setStreamingText("");
+        setStreamingToolCalls([]);
+        setStatus("thinking");
+        const controller = new AbortController();
+        abortRef.current = controller;
+        const timeoutId = setTimeout(() => controller.abort(), 10 * 60 * 1e3);
+        try {
+          const model = modelRef.current;
+          const systemPrompt = buildSystemPrompt(workingDirRef.current);
+          const stream = streamText({
+            model,
+            system: systemPrompt,
+            messages: session.messages.map((m) => ({
+              role: m.role,
+              content: m.content
+            })),
+            tools: getActiveTools(),
+            stopWhen: stepCountIs(100),
+            abortSignal: controller.signal,
+            ...buildOllamaOptions(
+              aiProviderRef.current,
+              options.contextLength
+            ),
+            onStepFinish({ text }) {
+              if (text) {
+                setMessages((prev) => [
+                  ...prev,
+                  {
+                    id: crypto2.randomUUID(),
+                    role: "assistant",
+                    content: text,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  }
+                ]);
+                setStreamingText(text);
+                setStatus("streaming");
+              }
+            }
+          });
+          for await (const _chunk of stream.textStream) {
           }
+          clearTimeout(timeoutId);
+          const finalText = await stream.text;
+          const usage = await stream.totalUsage;
+          const inputTokens = usage?.inputTokens ?? 0;
+          const outputTokens = usage?.outputTokens ?? 0;
+          setStreamingToolCalls([]);
+          setStreamingText("");
+          addMessage(session, "assistant", finalText);
+          session.totalTokens += inputTokens + outputTokens;
+          costTrackerRef.current.addUsage(
+            "agent",
+            options.provider,
+            options.model,
+            inputTokens,
+            outputTokens
+          );
+          setTokens(inputTokens);
+          setCost(costTrackerRef.current.getTotalCost());
+          saveSession(session);
+          const compactionLevel = shouldCompact(
+            inputTokens,
+            options.model,
+            options.contextLength
+          );
+          if (compactionLevel !== "none") {
+            setStatus("thinking");
+            const plainMessages = session.messages.map((m) => ({
+              role: m.role,
+              content: m.content
+            }));
+            const compacted = await compactMessages(
+              model,
+              plainMessages,
+              compactionLevel
+            );
+            session.messages = compacted.map((m) => ({
+              role: m.role,
+              content: m.content,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }));
+            saveSession(session);
+          }
+          setStatus("idle");
+          abortRef.current = null;
+        } catch (err) {
+          clearTimeout(timeoutId);
+          abortRef.current = null;
+          if (err instanceof Error && err.name === "AbortError") {
+            setStatus("idle");
+            return;
+          }
+          const errText = err instanceof Error ? err.message : String(err);
+          const errorMsg = {
+            id: crypto2.randomUUID(),
+            role: "assistant",
+            content: `Error: ${errText}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          setMessages((prev) => [...prev, errorMsg]);
+          setStreamingText("");
+          setStreamingToolCalls([]);
+          setStatus("idle");
         }
-        if (loaded) {
-          Object.assign(ctx.session, loaded);
-          console.log(chalk2.green(`
-  Switched to session ${loaded.id.slice(0, 8)} (${loaded.messages.length} messages)
-`));
-        } else {
-          console.log(chalk2.red(`
-  Session not found: ${targetId}
-`));
+      })();
+    },
+    [getActiveTools, options.provider, options.model, options.contextLength]
+  );
+  const cancel = useCallback(() => {
+    if (abortRef.current) {
+      abortRef.current.abort();
+      abortRef.current = null;
+      killActiveProcess();
+    }
+    setStatus("idle");
+    setStreamingText("");
+    setStreamingToolCalls([]);
+    setPermissionRequest(null);
+  }, []);
+  const setTrustAll = useCallback((v) => {
+    setTrustAllState(v);
+    trustAllRef.current = v;
+  }, []);
+  const setPlanMode = useCallback((v) => {
+    setPlanModeState(v);
+    planModeRef.current = v;
+  }, []);
+  const addSystemMessage = useCallback((content) => {
+    const msg = {
+      id: crypto2.randomUUID(),
+      role: "assistant",
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    setMessages((prev) => [...prev, msg]);
+  }, []);
+  const addUserMessage = useCallback((content) => {
+    const msg = {
+      id: crypto2.randomUUID(),
+      role: "user",
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    setMessages((prev) => [...prev, msg]);
+  }, []);
+  return {
+    messages,
+    streamingText,
+    streamingToolCalls,
+    status,
+    permissionRequest,
+    tokens,
+    cost,
+    session: sessionRef.current,
+    submit,
+    cancel,
+    setTrustAll,
+    setPlanMode,
+    addSystemMessage,
+    addUserMessage
+  };
+}
+
+// src/ui/useOrchestrator.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+var PERSONA_EMOJIS = {
+  frontend_developer: "\u{1F3A8}",
+  // 🎨
+  backend_developer: "\u{1F4BB}",
+  // 💻
+  fullstack_developer: "\u{1F4BB}",
+  // 💻
+  devops_engineer: "\u{1F527}",
+  // 🔧
+  security_engineer: "\u{1F512}",
+  // 🔐
+  qa_engineer: "\u{1F9EA}",
+  // 🧪
+  tech_writer: "\u{1F4DD}",
+  // 📝
+  project_manager: "\u{1F4CB}",
+  // 📋
+  architect: "\u{1F3D7}\uFE0F",
+  // 🏗️
+  database_engineer: "\u{1F4CA}",
+  // 📊
+  data_engineer: "\u{1F4CA}",
+  // 📊
+  data_ml_engineer: "\u{1F4CA}",
+  // 📊
+  ml_engineer: "\u{1F4CA}",
+  // 📊
+  mobile_developer: "\u{1F4F1}",
+  // 📱
+  tech_lead: "\u{1F451}",
+  // 👑
+  manager: "\u{1F454}",
+  // 👔
+  support_agent: "\u{1F4AC}",
+  // 💬
+  planner: "\u{1F4A1}",
+  // 💡
+  coordinator: "\u{1F3AF}",
+  // 🎯
+  critic: "\u{1F50D}",
+  // 🔍
+  reviewer: "\u{1F50D}"
+  // 🔍
+};
+function getEmoji(persona) {
+  return PERSONA_EMOJIS[persona] || "\u{1F916}";
+}
+function useOrchestrator(addMessage2) {
+  const [running, setRunning] = useState2(false);
+  const [statusMessage, setStatusMessage] = useState2("");
+  const [confirmRequest, setConfirmRequest] = useState2(null);
+  const start = useCallback2(
+    (task, trustAll, sandboxed) => {
+      setRunning(true);
+      setStatusMessage("");
+      setConfirmRequest(null);
+      void (async () => {
+        try {
+          const config = loadConfig();
+          if (!config) {
+            addMessage2(
+              "No provider configured. Run `workermill` (setup) first."
+            );
+            setRunning(false);
+            return;
+          }
+          const { classifyComplexity, runOrchestration } = await import("./orchestrator-5I7BGPC7.js");
+          const output = {
+            log(persona, message) {
+              const emoji = getEmoji(persona);
+              const trimmed = message.trim();
+              if (trimmed) {
+                addMessage2(`[${emoji} ${persona}] ${trimmed}`);
+              }
+            },
+            coordinatorLog(message) {
+              addMessage2(`[${getEmoji("coordinator")} coordinator] ${message}`);
+            },
+            error(message) {
+              addMessage2(`**Error:** ${message}`);
+            },
+            status(message) {
+              setStatusMessage(message);
+            },
+            statusDone(message) {
+              if (message) {
+                addMessage2(message);
+              }
+              setStatusMessage("");
+            },
+            confirm(prompt) {
+              return new Promise((resolve) => {
+                setConfirmRequest({
+                  prompt,
+                  resolve: (yes) => {
+                    setConfirmRequest(null);
+                    resolve(yes);
+                  }
+                });
+              });
+            },
+            toolCall(persona, toolName, toolInput) {
+              let detail = "";
+              if (toolInput.file_path) {
+                detail = String(toolInput.file_path);
+              } else if (toolInput.path) {
+                detail = String(toolInput.path);
+              } else if (toolInput.command) {
+                const cmd = String(toolInput.command);
+                detail = cmd.length > 120 ? cmd.slice(0, 117) + "..." : cmd;
+              } else if (toolInput.query) {
+                detail = String(toolInput.query).slice(0, 120);
+              } else if (toolInput.prompt) {
+                detail = String(toolInput.prompt).slice(0, 120);
+              } else if (toolInput.pattern) {
+                detail = `pattern: ${String(toolInput.pattern)}`;
+              } else if (toolInput.url) {
+                detail = String(toolInput.url);
+              } else if (toolInput.action) {
+                detail = String(toolInput.action);
+              } else {
+                const keys = Object.keys(toolInput).slice(0, 3);
+                if (keys.length > 0) {
+                  detail = keys.map((k) => `${k}: ${String(toolInput[k]).slice(0, 80)}`).join(", ");
+                }
+              }
+              const emoji = getEmoji(persona);
+              addMessage2(
+                `[${emoji} ${persona}] \u2193 ${toolName}${detail ? " " + detail : ""}`
+              );
+            }
+          };
+          addMessage2("Analyzing task complexity\u2026");
+          const classification = await classifyComplexity(config, task, output);
+          if (!classification.isMulti) {
+            addMessage2(
+              `Task classified as single-agent (${classification.reason}). Use a normal prompt instead of /build for single tasks.`
+            );
+            setRunning(false);
+            return;
+          }
+          addMessage2(
+            `Task classified as multi-expert: ${classification.reason}`
+          );
+          await runOrchestration(config, task, trustAll, sandboxed, output);
+          addMessage2("**Orchestration complete.**");
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          addMessage2(`**Orchestration failed:** ${msg}`);
+        } finally {
+          setRunning(false);
+          setStatusMessage("");
+          setConfirmRequest(null);
         }
-        break;
-      }
-      const sessions = listSessions();
-      if (sessions.length === 0) {
-        console.log(chalk2.dim("\n  No saved sessions.\n"));
-        break;
-      }
-      console.log(chalk2.bold("\n  Recent Sessions:"));
-      sessions.forEach((s, i) => {
-        const date = new Date(s.startedAt).toLocaleDateString();
-        const current = s.id === ctx.session.id ? chalk2.green(" <- current") : "";
-        console.log(chalk2.dim(`  ${i + 1}. `) + chalk2.white(`${s.name || s.preview}`) + chalk2.dim(` (${s.messageCount} msgs, ${date})`) + current);
-      });
-      console.log(chalk2.dim(`
-  Use /sessions <n> to switch, /sessions delete <id> to delete.
-`));
+      })();
+    },
+    [addMessage2]
+  );
+  return { running, start, statusMessage, confirmRequest };
+}
+
+// src/ui/App.tsx
+import React3, { useRef as useRef2 } from "react";
+import { Box as Box6, Text as Text6, Static, useApp, useInput as useInput3, useStdout as useStdout2 } from "ink";
+
+// src/ui/Markdown.tsx
+import { Box, Text } from "ink";
+
+// src/ui/theme.ts
+var theme = {
+  /** Brand/diamond color — warm orange. */
+  brand: "#D77757",
+  /** Primary text on dark background. */
+  text: "#FFFFFF",
+  /** Subtle/dim text — light gray. */
+  subtle: "#AFAFAF",
+  /** Subtle/dim text — dark gray. */
+  subtleDark: "#505050",
+  /** Pure black background. */
+  background: "#000000",
+  /** User message background tint. */
+  userBg: "#373737",
+  /** Success indicators. */
+  success: "#4EBA65",
+  /** Warning indicators. */
+  warning: "#FFCC00",
+  /** Error indicators. */
+  error: "#FF6B80",
+  /** Permission/suggestion accent — blue-purple. */
+  permission: "#5769F7",
+  /** Ice blue for highlights. */
+  iceBlue: "#ADD8E6",
+  /** Professional blue for Read/file tools. */
+  blue: "#6A9BCC",
+  /** Bash border — pink/magenta. */
+  bashBorder: "#FD5DB1",
+  /** Inactive/disabled elements. */
+  inactive: "#666666",
+  /** Default border color. */
+  border: "gray"
+};
+var toolColors = {
+  Read: theme.blue,
+  Write: theme.warning,
+  Edit: theme.warning,
+  Bash: theme.bashBorder,
+  Glob: theme.iceBlue,
+  Grep: theme.iceBlue,
+  List: theme.subtle,
+  Fetch: theme.blue,
+  Patch: theme.warning,
+  Agent: theme.permission,
+  Git: theme.success,
+  Search: theme.blue,
+  Todo: theme.subtle
+};
+var syntax = {
+  keyword: "#C586C0",
+  string: "#4EBA65",
+  comment: "#666666",
+  type: "#FFCC00",
+  number: "#B5CEA8",
+  punctuation: "#AFAFAF",
+  default: "#FFFFFF"
+};
+
+// src/ui/Markdown.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function highlightCode(line, lang) {
+  const parts = [];
+  let remaining = line;
+  let idx = 0;
+  const commentPatterns = [/^(\s*\/\/.*)/, /^(\s*#.*)/, /^(\s*--.*)/, /^(\s*\/\*.*\*\/)/];
+  for (const cp of commentPatterns) {
+    const cm = remaining.match(cp);
+    if (cm) {
+      return [/* @__PURE__ */ jsx(Text, { color: syntax.comment, children: remaining }, `c-${idx}`)];
+    }
+  }
+  const stringRe = /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/;
+  const keywordRe = /\b(import|export|from|const|let|var|function|class|interface|type|return|if|else|for|while|do|switch|case|break|continue|new|this|super|extends|implements|async|await|try|catch|finally|throw|typeof|instanceof|in|of|as|default|void|null|undefined|true|false|def|fn|pub|mod|use|struct|enum|impl|trait|match|self|mut|ref|where|crate|macro|move|loop|static|extern|unsafe|dyn)\b/;
+  const typeRe = /\b([A-Z][a-zA-Z0-9]+)\b/;
+  const numberRe = /\b(\d+\.?\d*(?:e[+-]?\d+)?)\b/;
+  while (remaining.length > 0) {
+    const candidates = [];
+    const sm = stringRe.exec(remaining);
+    if (sm) candidates.push({ type: "string", match: sm, pos: sm.index });
+    const km = keywordRe.exec(remaining);
+    if (km) candidates.push({ type: "keyword", match: km, pos: km.index });
+    const tm = typeRe.exec(remaining);
+    if (tm) candidates.push({ type: "type", match: tm, pos: tm.index });
+    const nm = numberRe.exec(remaining);
+    if (nm) candidates.push({ type: "number", match: nm, pos: nm.index });
+    candidates.sort((a, b) => a.pos - b.pos);
+    const winner = candidates[0];
+    if (!winner) {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: syntax.default, children: remaining }, `d-${idx++}`));
       break;
     }
-    case "editor": {
-      const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-      const tmpFile = path2.join(os.tmpdir(), `workermill-${Date.now()}.md`);
-      fs2.writeFileSync(tmpFile, "", "utf-8");
-      try {
-        execSync2(`${editor} ${tmpFile}`, { stdio: "inherit" });
-        const content = fs2.readFileSync(tmpFile, "utf-8").trim();
-        fs2.unlinkSync(tmpFile);
-        if (content) {
-          ctx.processInput(content);
-        } else {
-          console.log(chalk2.dim("\n  Empty input, cancelled.\n"));
-        }
-      } catch {
-        console.log(chalk2.red("\n  Editor failed.\n"));
-      }
+    if (winner.pos > 0) {
+      parts.push(
+        /* @__PURE__ */ jsx(Text, { color: syntax.default, children: remaining.slice(0, winner.pos) }, `d-${idx++}`)
+      );
+    }
+    const matchStr = winner.type === "string" ? winner.match[0] : winner.match[1];
+    const fullMatch = winner.type === "string" ? winner.match[0] : winner.match[0];
+    const color = winner.type === "string" ? syntax.string : winner.type === "keyword" ? syntax.keyword : winner.type === "type" ? syntax.type : syntax.number;
+    parts.push(
+      /* @__PURE__ */ jsx(Text, { color, children: matchStr }, `h-${idx++}`)
+    );
+    remaining = remaining.slice(winner.pos + fullMatch.length);
+  }
+  return parts;
+}
+function renderInline(line, key) {
+  const parts = [];
+  let remaining = line;
+  let idx = 0;
+  while (remaining.length > 0) {
+    const boldMatch = remaining.match(/^(.*?)\*\*(.+?)\*\*/);
+    const boldMatch2 = remaining.match(/^(.*?)__(.+?)__/);
+    const bold = boldMatch && (!boldMatch2 || boldMatch.index <= boldMatch2.index) ? boldMatch : boldMatch2;
+    const codeMatch = remaining.match(/^(.*?)`([^`]+)`/);
+    const candidates = [];
+    if (bold) candidates.push({ type: "bold", match: bold, pos: bold[1].length });
+    if (codeMatch) candidates.push({ type: "code", match: codeMatch, pos: codeMatch[1].length });
+    candidates.sort((a, b) => a.pos - b.pos);
+    const winner = candidates[0];
+    if (!winner) {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: theme.text, children: remaining }, `${key}-${idx++}`));
       break;
     }
-    case "plan": {
-      const arg = parts[1];
-      if (arg === "off" || ctx.planMode) {
-        ctx.setPlanMode(false);
-        console.log(chalk2.green("\n  Plan mode off. Full tools available.\n"));
-      } else {
-        ctx.setPlanMode(true);
-        console.log(chalk2.cyan("\n  [PLAN MODE] Read-only tools only. Use /plan off to exit.\n"));
+    const m = winner.match;
+    if (m[1]) {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: theme.text, children: m[1] }, `${key}-${idx++}`));
+    }
+    if (winner.type === "bold") {
+      parts.push(/* @__PURE__ */ jsx(Text, { bold: true, color: theme.text, children: m[2] }, `${key}-${idx++}`));
+    } else {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: theme.iceBlue, children: m[2] }, `${key}-${idx++}`));
+    }
+    remaining = remaining.slice(m[0].length);
+  }
+  if (parts.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { children: " " }, key);
+  }
+  return /* @__PURE__ */ jsx(Text, { children: parts }, key);
+}
+function renderCodeBlock(lines, lang, key) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 1, marginY: 0, children: [
+    lang && /* @__PURE__ */ jsx(Text, { color: theme.subtle, children: `  ${lang}` }),
+    /* @__PURE__ */ jsx(
+      Box,
+      {
+        borderStyle: "round",
+        borderColor: theme.subtleDark,
+        paddingX: 1,
+        flexDirection: "column",
+        children: lines.map((codeLine, i) => /* @__PURE__ */ jsx(Text, { children: highlightCode(codeLine || " ", lang) }, `${key}-code-${i}`))
       }
-      break;
+    )
+  ] }, key);
+}
+function Markdown({ content }) {
+  const sourceLines = content.split("\n");
+  const elements = [];
+  let i = 0;
+  let elemKey = 0;
+  while (i < sourceLines.length) {
+    const line = sourceLines[i];
+    const fenceMatch = line.match(/^```(\w*)/);
+    if (fenceMatch) {
+      const lang = fenceMatch[1] || "";
+      const codeLines = [];
+      i++;
+      while (i < sourceLines.length && !sourceLines[i].startsWith("```")) {
+        codeLines.push(sourceLines[i]);
+        i++;
+      }
+      if (i < sourceLines.length) i++;
+      elements.push(renderCodeBlock(codeLines, lang, `block-${elemKey++}`));
+      continue;
+    }
+    if (/^(---|\*\*\*|___)/.test(line.trim())) {
+      elements.push(
+        /* @__PURE__ */ jsx(Text, { color: theme.subtleDark, children: "\u2500".repeat(60) }, `hr-${elemKey++}`)
+      );
+      i++;
+      continue;
+    }
+    const headerMatch = line.match(/^(#{1,6})\s+(.*)/);
+    if (headerMatch) {
+      const depth = headerMatch[1].length;
+      const text = headerMatch[2];
+      elements.push(
+        /* @__PURE__ */ jsx(
+          Text,
+          {
+            bold: true,
+            color: depth <= 2 ? theme.text : theme.subtle,
+            children: text
+          },
+          `h-${elemKey++}`
+        )
+      );
+      i++;
+      continue;
+    }
+    if (line.startsWith(">")) {
+      const quoteText = line.replace(/^>\s?/, "");
+      elements.push(
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: theme.subtleDark, children: "  \u2502 " }),
+          /* @__PURE__ */ jsx(Text, { color: theme.subtle, children: quoteText })
+        ] }, `bq-${elemKey++}`)
+      );
+      i++;
+      continue;
     }
-    case "quit":
-    case "exit": {
-      const { exitTerminal: exitTerminal2 } = await import("./terminal-ILMO7Z3P.js");
-      exitTerminal2();
-      console.log(chalk2.dim("  Goodbye!"));
-      process.exit(0);
+    const listMatch = line.match(/^(\s*)[-*]\s+(.*)/);
+    if (listMatch) {
+      const indent = listMatch[1] || "";
+      const text = listMatch[2];
+      elements.push(
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Text, { color: theme.subtle, children: [
+            indent,
+            "  ",
+            "\u2022 "
+          ] }),
+          renderInline(text, `li-inline-${elemKey}`)
+        ] }, `li-${elemKey++}`)
+      );
+      i++;
+      continue;
+    }
+    const olMatch = line.match(/^(\s*)\d+\.\s+(.*)/);
+    if (olMatch) {
+      const indent = olMatch[1] || "";
+      const text = olMatch[2];
+      const numMatch = line.match(/^(\s*)(\d+)\./);
+      const num = numMatch ? numMatch[2] : "1";
+      elements.push(
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Text, { color: theme.subtle, children: [
+            indent,
+            "  ",
+            num,
+            ". "
+          ] }),
+          renderInline(text, `ol-inline-${elemKey}`)
+        ] }, `ol-${elemKey++}`)
+      );
+      i++;
+      continue;
+    }
+    if (line.trim() === "") {
+      elements.push(/* @__PURE__ */ jsx(Text, { children: " " }, `empty-${elemKey++}`));
+      i++;
+      continue;
+    }
+    elements.push(
+      /* @__PURE__ */ jsx(Box, { children: renderInline(line, `inline-${elemKey}`) }, `p-${elemKey++}`)
+    );
+    i++;
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: elements });
+}
+
+// src/ui/ToolCall.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var LABELS = {
+  bash: "Bash",
+  read_file: "Read",
+  write_file: "Write",
+  edit_file: "Edit",
+  glob: "Glob",
+  grep: "Grep",
+  ls: "List",
+  fetch: "Fetch",
+  patch: "Patch",
+  sub_agent: "Agent",
+  git: "Git",
+  web_search: "Search",
+  todo: "Todo"
+};
+var SPINNER_FRAMES = ["\u28CB", "\u28D9", "\u28F9", "\u28F8", "\u28FC", "\u28F4", "\u28E6", "\u28E7", "\u28C7", "\u28CF"];
+function extractDetail(input) {
+  if (input.file_path) return String(input.file_path);
+  if (input.path) return String(input.path);
+  if (input.command) {
+    const cmd = String(input.command);
+    return cmd.length > 80 ? cmd.slice(0, 77) + "..." : cmd;
+  }
+  if (input.pattern) return `pattern: ${String(input.pattern)}`;
+  if (input.query) return String(input.query).slice(0, 80);
+  const keys = Object.keys(input).slice(0, 2);
+  if (keys.length === 0) return "";
+  return keys.map((k) => {
+    const v = String(input[k]);
+    return `${k}: ${v.length > 40 ? v.slice(0, 37) + "..." : v}`;
+  }).join(", ");
+}
+function ToolCallDisplay({ tool }) {
+  const label = LABELS[tool.name] || tool.name;
+  const detail = extractDetail(tool.input);
+  const labelColor = toolColors[label] || theme.blue;
+  let statusIcon;
+  switch (tool.status) {
+    case "done":
+      statusIcon = /* @__PURE__ */ jsx2(Text2, { color: theme.success, children: "\u2713" });
+      break;
+    case "denied":
+      statusIcon = /* @__PURE__ */ jsx2(Text2, { color: theme.error, children: "\u2717" });
+      break;
+    case "running": {
+      const frame = SPINNER_FRAMES[Math.floor(Date.now() / 100) % SPINNER_FRAMES.length];
+      statusIcon = /* @__PURE__ */ jsx2(Text2, { color: theme.warning, children: frame });
       break;
     }
     default:
-      console.log(chalk2.yellow(`
-  Unknown command: /${command}. Type /help for available commands.
-`));
+      statusIcon = /* @__PURE__ */ jsx2(Text2, { color: theme.subtle, children: "\u2193" });
+      break;
   }
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { children: "  " }),
+    statusIcon,
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: labelColor, children: label }),
+    detail ? /* @__PURE__ */ jsxs2(Text2, { color: theme.subtle, children: [
+      " ",
+      detail
+    ] }) : null
+  ] });
 }
 
-// src/logger.js
-import fs3 from "fs";
-import path3 from "path";
-var LOG_DIR = path3.join(process.cwd(), ".workermill");
-var LOG_FILE = path3.join(LOG_DIR, "cli.log");
-var logStream = null;
-function ensureLogDir() {
-  if (!fs3.existsSync(LOG_DIR)) {
-    fs3.mkdirSync(LOG_DIR, { recursive: true });
+// src/ui/PermissionPrompt.tsx
+import { useState as useState3 } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function describeAction(request) {
+  const input = request.toolInput;
+  if (input.file_path) return String(input.file_path);
+  if (input.path) return String(input.path);
+  if (input.command) {
+    const cmd = String(input.command);
+    return cmd.length > 120 ? cmd.slice(0, 117) + "..." : cmd;
   }
+  if (input.pattern) return `pattern: ${String(input.pattern)}`;
+  return "";
 }
-function getStream() {
-  if (!logStream) {
-    ensureLogDir();
-    logStream = fs3.createWriteStream(LOG_FILE, { flags: "a" });
-  }
-  return logStream;
+function PermissionPrompt({ request }) {
+  const options = request.isDangerous ? [
+    { key: "y", label: "Yes, allow" },
+    { key: "n", label: "No, deny" }
+  ] : [
+    { key: "y", label: "Allow" },
+    { key: "n", label: "Deny" },
+    { key: "a", label: "Always allow this tool" },
+    { key: "t", label: "Trust all tools" }
+  ];
+  const [selected, setSelected] = useState3(0);
+  const [resolved, setResolved] = useState3(false);
+  useInput(
+    (input, key) => {
+      if (resolved) return;
+      if (key.upArrow) {
+        setSelected((s) => Math.max(0, s - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setSelected((s) => Math.min(options.length - 1, s + 1));
+        return;
+      }
+      if (key.return) {
+        setResolved(true);
+        const opt = options[selected];
+        if (opt.key === "n") request.resolve(false);
+        else if (opt.key === "t") request.resolve(true, "trust");
+        else if (opt.key === "a") request.resolve(true, "always");
+        else request.resolve(true);
+        return;
+      }
+      if (input === "y" || input === "Y") {
+        setResolved(true);
+        request.resolve(true);
+      } else if (input === "n" || input === "N") {
+        setResolved(true);
+        request.resolve(false);
+      } else if (!request.isDangerous && (input === "a" || input === "A")) {
+        setResolved(true);
+        request.resolve(true, "always");
+      } else if (!request.isDangerous && (input === "t" || input === "T")) {
+        setResolved(true);
+        request.resolve(true, "trust");
+      }
+    },
+    { isActive: !resolved }
+  );
+  const detail = describeAction(request);
+  const borderColor = request.isDangerous ? theme.error : theme.permission;
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      marginY: 1,
+      marginLeft: 2,
+      children: [
+        request.isDangerous ? /* @__PURE__ */ jsxs3(Text3, { color: theme.error, bold: true, children: [
+          "\u26A0 ",
+          "Dangerous: ",
+          request.dangerLabel || request.toolName
+        ] }) : /* @__PURE__ */ jsxs3(Text3, { color: theme.permission, bold: true, children: [
+          "? ",
+          "Allow ",
+          /* @__PURE__ */ jsx3(Text3, { color: theme.text, bold: true, children: request.toolName })
+        ] }),
+        detail ? /* @__PURE__ */ jsxs3(Text3, { color: theme.subtle, children: [
+          "  ",
+          detail
+        ] }) : null,
+        /* @__PURE__ */ jsx3(Text3, { children: " " }),
+        options.map((opt, i) => {
+          const isSelected = i === selected;
+          const radio = isSelected ? "\u25C9" : "\u25CB";
+          return /* @__PURE__ */ jsx3(Box3, { marginLeft: 1, children: /* @__PURE__ */ jsxs3(
+            Text3,
+            {
+              color: isSelected ? theme.permission : theme.subtle,
+              bold: isSelected,
+              children: [
+                radio,
+                " (",
+                opt.key,
+                ") ",
+                opt.label
+              ]
+            }
+          ) }, opt.key);
+        })
+      ]
+    }
+  );
 }
-function timestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString();
+
+// src/ui/StatusBar.tsx
+import { Box as Box4, Text as Text4, useStdout } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
 }
-function log(level, message, data) {
-  const entry = data ? `[${timestamp()}] ${level}: ${message} ${JSON.stringify(data)}` : `[${timestamp()}] ${level}: ${message}`;
-  getStream().write(entry + "\n");
+function formatCost(c) {
+  if (c < 0.01) return "$0.00";
+  return `$${c.toFixed(2)}`;
 }
-function info(message, data) {
-  log("INFO", message, data);
+function StatusBar(props) {
+  const { stdout } = useStdout();
+  const width = stdout?.columns || 80;
+  const barLen = 8;
+  const usage = Math.min(1, props.maxContext > 0 ? props.tokens / props.maxContext : 0);
+  const filled = Math.round(usage * barLen);
+  const empty = barLen - filled;
+  const barColor = usage < 0.5 ? theme.success : usage < 0.8 ? theme.warning : theme.error;
+  let modeColor;
+  switch (props.mode) {
+    case "PLAN":
+      modeColor = theme.bashBorder;
+      break;
+    case "trust all":
+      modeColor = theme.error;
+      break;
+    default:
+      modeColor = theme.success;
+      break;
+  }
+  const bgColor = theme.subtleDark;
+  const modelStr = ` ${props.provider}/${props.model} `;
+  const tokenStr = ` ${formatTokens(props.tokens)} `;
+  const costStr = formatCost(props.cost);
+  const branchStr = props.gitBranch ? ` git:(${props.gitBranch})` : "";
+  const cwdStr = props.cwd ? ` ${props.cwd}` : "";
+  const rightStr = `${cwdStr}${branchStr} | ${costStr} `;
+  const fixedLen = modelStr.length + barLen + tokenStr.length + rightStr.length + props.mode.length + 2;
+  const padding = Math.max(0, width - fixedLen);
+  return /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, color: theme.text, children: modelStr }),
+    /* @__PURE__ */ jsxs4(Text4, { backgroundColor: bgColor, color: barColor, children: [
+      "\u2588".repeat(filled),
+      "\u2591".repeat(empty)
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, color: theme.text, children: tokenStr }),
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, children: " ".repeat(padding) }),
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, color: theme.text, children: cwdStr }),
+    props.gitBranch ? /* @__PURE__ */ jsxs4(Text4, { backgroundColor: bgColor, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: theme.text, children: " git:(" }),
+      /* @__PURE__ */ jsx4(Text4, { color: theme.success, children: props.gitBranch }),
+      /* @__PURE__ */ jsx4(Text4, { color: theme.text, children: ")" })
+    ] }) : null,
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, color: theme.subtle, children: " | " }),
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, color: theme.text, children: costStr }),
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, color: theme.text, children: " " }),
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, color: modeColor, bold: true, children: props.mode }),
+    /* @__PURE__ */ jsx4(Text4, { backgroundColor: bgColor, children: " " })
+  ] });
 }
-function error(message, data) {
-  log("ERROR", message, data);
+
+// src/ui/Input.tsx
+import { useState as useState4 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function Input({ onSubmit, isActive, history }) {
+  const [value, setValue] = useState4("");
+  const [historyIndex, setHistoryIndex] = useState4(-1);
+  useInput2(
+    (input, key) => {
+      if (!isActive) return;
+      if (key.return) {
+        const trimmed = value.trim();
+        if (trimmed) {
+          onSubmit(trimmed);
+          setValue("");
+          setHistoryIndex(-1);
+        }
+        return;
+      }
+      if (key.upArrow) {
+        const newIdx = Math.min(historyIndex + 1, history.length - 1);
+        if (newIdx >= 0 && history[newIdx]) {
+          setHistoryIndex(newIdx);
+          setValue(history[newIdx]);
+        }
+        return;
+      }
+      if (key.downArrow) {
+        const newIdx = historyIndex - 1;
+        setHistoryIndex(newIdx);
+        if (newIdx >= 0 && history[newIdx]) {
+          setValue(history[newIdx]);
+        } else {
+          setValue("");
+        }
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setValue((v) => v.slice(0, -1));
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        setValue("");
+        return;
+      }
+      if (key.ctrl && input === "w") {
+        setValue((v) => v.replace(/\S+\s*$/, ""));
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setValue((v) => v + input);
+      }
+    },
+    { isActive }
+  );
+  return /* @__PURE__ */ jsxs5(Box5, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color: isActive ? theme.brand : theme.inactive, bold: true, children: isActive ? "\u25C6 " : "\u25C7 " }),
+    /* @__PURE__ */ jsx5(Text5, { color: theme.text, children: value }),
+    isActive && /* @__PURE__ */ jsx5(Text5, { inverse: true, children: " " })
+  ] });
 }
-function debug(message, data) {
-  log("DEBUG", message, data);
+
+// src/ui/App.tsx
+import { Fragment, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function OrchestratorConfirm({ request }) {
+  const [answered, setAnswered] = React3.useState(false);
+  useInput3((input) => {
+    if (answered) return;
+    if (input === "y" || input === "Y") {
+      setAnswered(true);
+      request.resolve(true);
+    }
+    if (input === "n" || input === "N") {
+      setAnswered(true);
+      request.resolve(false);
+    }
+  }, { isActive: !answered });
+  return /* @__PURE__ */ jsxs6(Box6, { marginLeft: 2, marginY: 1, children: [
+    /* @__PURE__ */ jsxs6(Text6, { color: theme.permission, children: [
+      request.prompt,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "(y/n)" })
+  ] });
 }
-function flush() {
-  if (logStream) {
-    logStream.end();
-    logStream = null;
-  }
+function App(props) {
+  const { exit } = useApp();
+  const { stdout } = useStdout2();
+  const lastCtrlCRef = useRef2(0);
+  const width = stdout?.columns || 80;
+  useInput3((input, key) => {
+    if (key.ctrl && input === "c") {
+      const now = Date.now();
+      if (props.status === "idle" && now - lastCtrlCRef.current < 500) {
+        exit();
+        return;
+      }
+      lastCtrlCRef.current = now;
+    }
+  });
+  const mode = props.planMode ? "PLAN" : props.trustAll ? "trust all" : "ask";
+  const headerInner = Math.min(width - 4, 50);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", width: "100%", children: [
+    /* @__PURE__ */ jsx6(Static, { items: [{ id: "__header__" }], children: () => /* @__PURE__ */ jsxs6(
+      Box6,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: theme.subtleDark,
+        paddingX: 1,
+        width: headerInner,
+        children: [
+          /* @__PURE__ */ jsxs6(Box6, { children: [
+            /* @__PURE__ */ jsx6(Text6, { color: theme.brand, children: "\u25C6 " }),
+            /* @__PURE__ */ jsx6(Text6, { color: theme.text, bold: true, children: "WorkerMill" })
+          ] }),
+          /* @__PURE__ */ jsx6(Text6, { children: " " }),
+          /* @__PURE__ */ jsxs6(Text6, { color: theme.subtle, children: [
+            "  ",
+            props.provider,
+            "/",
+            props.model
+          ] }),
+          /* @__PURE__ */ jsxs6(Text6, { color: theme.subtle, children: [
+            "  ",
+            "cwd: ",
+            props.workingDir
+          ] }),
+          /* @__PURE__ */ jsxs6(Text6, { color: theme.subtle, children: [
+            "  ",
+            "Type ",
+            /* @__PURE__ */ jsx6(Text6, { color: theme.text, children: "/help" }),
+            " for commands"
+          ] })
+        ]
+      },
+      "__header__"
+    ) }),
+    /* @__PURE__ */ jsx6(Static, { items: props.messages, children: (message) => /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", marginTop: 1, children: message.role === "user" ? /* @__PURE__ */ jsxs6(Box6, { marginLeft: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: theme.brand, bold: true, children: "\u2771 " }),
+      /* @__PURE__ */ jsx6(Text6, { color: theme.text, children: message.content })
+    ] }) : /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginLeft: 2, children: [
+      message.toolCalls?.map((tc) => /* @__PURE__ */ jsx6(ToolCallDisplay, { tool: tc }, tc.id)),
+      message.content ? /* @__PURE__ */ jsx6(Markdown, { content: message.content }) : null
+    ] }) }, message.id) }),
+    /* @__PURE__ */ jsx6(Box6, { marginLeft: 2, height: 1, children: props.orchestratorStatus ? /* @__PURE__ */ jsxs6(Text6, { color: theme.warning, children: [
+      "\u25CF ",
+      props.orchestratorStatus
+    ] }) : props.status === "thinking" ? /* @__PURE__ */ jsx6(Text6, { color: theme.subtle, children: "\u25CF Thinking..." }) : props.status === "streaming" ? /* @__PURE__ */ jsx6(Text6, { color: theme.brand, children: "\u25CF Streaming response..." }) : props.status === "tool_running" ? /* @__PURE__ */ jsx6(Text6, { color: theme.warning, children: "\u25CF Running tool..." }) : props.status === "permission" ? /* @__PURE__ */ jsx6(Text6, { color: theme.permission, children: "\u25CF Waiting for permission..." }) : /* @__PURE__ */ jsx6(Text6, { children: " " }) }),
+    props.permissionRequest ? /* @__PURE__ */ jsx6(PermissionPrompt, { request: props.permissionRequest }) : props.orchestratorConfirm ? /* @__PURE__ */ jsx6(OrchestratorConfirm, { request: props.orchestratorConfirm }) : /* @__PURE__ */ jsxs6(Fragment, { children: [
+      /* @__PURE__ */ jsx6(
+        StatusBar,
+        {
+          model: props.model,
+          provider: props.provider,
+          tokens: props.tokens,
+          maxContext: props.maxContext,
+          cost: props.cost,
+          mode,
+          gitBranch: props.gitBranch,
+          cwd: props.workingDir.split("/").pop() || ""
+        }
+      ),
+      /* @__PURE__ */ jsx6(
+        Input,
+        {
+          onSubmit: props.onSubmit,
+          isActive: props.status === "idle" && !props.orchestratorStatus,
+          history: props.inputHistory
+        }
+      )
+    ] })
+  ] });
 }
 
-// src/agent.js
-var HISTORY_FILE = pathModule.join(process.env.HOME || "~", ".workermill", "history");
+// src/ui/Root.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var HISTORY_DIR = path2.join(os.homedir(), ".workermill");
+var HISTORY_FILE = path2.join(HISTORY_DIR, "history");
 var MAX_HISTORY = 1e3;
 function loadHistory() {
   try {
-    if (fs4.existsSync(HISTORY_FILE)) {
-      const lines = fs4.readFileSync(HISTORY_FILE, "utf-8").split("\n").filter(Boolean);
-      return lines.slice(-MAX_HISTORY);
+    if (fs2.existsSync(HISTORY_FILE)) {
+      const raw = fs2.readFileSync(HISTORY_FILE, "utf-8").trim();
+      if (!raw) return [];
+      return raw.split("\n").slice(-MAX_HISTORY);
     }
   } catch {
   }
@@ -542,408 +1571,389 @@ function loadHistory() {
 }
 function appendHistory(line) {
   try {
-    const dir = pathModule.dirname(HISTORY_FILE);
-    if (!fs4.existsSync(dir))
-      fs4.mkdirSync(dir, { recursive: true });
-    fs4.appendFileSync(HISTORY_FILE, line + "\n", "utf-8");
+    if (!fs2.existsSync(HISTORY_DIR)) {
+      fs2.mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    fs2.appendFileSync(HISTORY_FILE, line + "\n", "utf-8");
   } catch {
   }
 }
-var SLASH_COMMANDS = [
-  "/help",
-  "/clear",
-  "/compact",
-  "/status",
-  "/model",
-  "/quit",
-  "/cost",
-  "/git",
-  "/editor",
-  "/plan",
-  "/sessions",
-  "/exit"
-];
-function completer(line) {
-  if (line.startsWith("/")) {
-    const hits = SLASH_COMMANDS.filter((c) => c.startsWith(line));
-    return [hits.length ? hits : SLASH_COMMANDS, line];
+function getGitBranch() {
+  try {
+    return execSync2("git rev-parse --abbrev-ref HEAD 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 2e3
+    }).trim();
+  } catch {
+    return "";
   }
-  return [[], line];
-}
-async function runAgent(config, trustAll, resume, startInPlanMode, fullDisk) {
-  const { provider, model: modelName, apiKey, host } = getProviderForPersona(config);
-  if (apiKey) {
-    const envMap = {
-      anthropic: "ANTHROPIC_API_KEY",
-      openai: "OPENAI_API_KEY",
-      google: "GOOGLE_API_KEY"
-    };
-    const envVar = envMap[provider];
-    if (envVar && !process.env[envVar]) {
-      process.env[envVar] = apiKey;
-    }
+}
+function getGitStatus(cwd) {
+  let branch = "(unknown)";
+  let status = "(unable to read)";
+  try {
+    branch = execSync2("git branch --show-current 2>/dev/null", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim() || "(detached HEAD)";
+  } catch {
+    branch = "(not a git repo)";
   }
-  const aiProvider = provider;
-  const model = createModel(aiProvider, modelName, host);
-  const workingDir = process.cwd();
-  const sandboxed = !fullDisk;
-  const tools = createToolDefinitions(workingDir, model, sandboxed);
-  const permissions = new PermissionManager(trustAll);
-  let session;
-  if (resume) {
-    const loaded = loadLatestSession();
-    if (loaded) {
-      session = loaded;
-      console.log(chalk3.green(`  Resumed session ${session.id.slice(0, 8)}... (${session.messages.length} messages)
-`));
-    } else {
-      session = createSession(provider, modelName);
-      console.log(chalk3.dim("  No previous session found, starting fresh.\n"));
-    }
-  } else {
-    session = createSession(provider, modelName);
+  try {
+    const raw = execSync2("git status --short 2>/dev/null", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    status = raw || "(clean)";
+  } catch {
+    status = "(not a git repo)";
   }
-  let agentState = "idle";
-  let currentAbortController = null;
-  let lastCtrlCTime = 0;
-  let planMode = startInPlanMode || false;
-  const costTracker = new CostTracker();
-  const READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["read_file", "glob", "grep", "ls", "sub_agent"]);
-  function getActiveTools() {
-    if (!planMode)
-      return permissionedTools;
-    const filtered = {};
-    for (const [name, def] of Object.entries(permissionedTools)) {
-      if (READ_ONLY_TOOLS.has(name)) {
-        filtered[name] = def;
+  return `**Git branch:** ${branch}
+
+\`\`\`
+${status}
+\`\`\``;
+}
+var HELP_TEXT = `**WorkerMill Commands**
+
+| Command | Description |
+|---|---|
+| \`/help\` | Show this help |
+| \`/model\` | Show current model info |
+| \`/cost\` | Show session cost breakdown |
+| \`/status\` | Show session status |
+| \`/plan\` | Toggle plan mode (read-only tools) |
+| \`/trust\` | Trust all tool calls for this session |
+| \`/build <task>\` | Multi-expert orchestration |
+| \`/git\` | Show git branch and status |
+| \`/sessions\` | List recent sessions |
+| \`/editor\` | Open \\$EDITOR, submit contents |
+| \`/compact\` | Trigger context compaction |
+| \`/clear\` | Clear screen (limited in Ink) |
+| \`/quit\` | Exit WorkerMill |
+| \`/exit\` | Exit WorkerMill |
+
+**Shortcuts**
+
+- \`!command\` -- Run a shell command directly and display output
+- \`Ctrl+C\` -- Cancel current operation
+- \`Ctrl+C Ctrl+C\` -- Exit when idle
+
+**Notes**
+
+- Multiline input is not currently supported. Paste single-line prompts or use \`/editor\` to compose longer messages.`;
+function Root(props) {
+  const { exit } = useApp2();
+  const agent = useAgent(props);
+  const addOrchestratorMessage = useCallback3(
+    (content, role) => {
+      if (role === "user") {
+        agent.addUserMessage(content);
+      } else {
+        agent.addSystemMessage(content);
       }
+    },
+    [agent]
+  );
+  const orchestrator = useOrchestrator(addOrchestratorMessage);
+  const [inputHistory, setInputHistory] = useState5(() => loadHistory());
+  const [gitBranch, setGitBranch] = useState5(() => getGitBranch());
+  const lastBranchCheck = useRef3(Date.now());
+  const refreshGitBranch = useCallback3(() => {
+    const now = Date.now();
+    if (now - lastBranchCheck.current > 1e4) {
+      lastBranchCheck.current = now;
+      setGitBranch(getGitBranch());
     }
-    return filtered;
-  }
-  const permissionedTools = {};
-  for (const [name, toolDef] of Object.entries(tools)) {
-    const td = toolDef;
-    permissionedTools[name] = {
-      ...td,
-      execute: async (input) => {
-        const prevState = agentState;
-        agentState = "permission_waiting";
-        const allowed = await permissions.checkPermission(name, input);
-        if (!allowed) {
-          agentState = prevState;
-          debug("Tool denied by user", { tool: name });
-          return "Tool execution denied by user.";
+  }, []);
+  const pushHistory = useCallback3((line) => {
+    setInputHistory((prev) => {
+      const next = [...prev, line].slice(-MAX_HISTORY);
+      return next;
+    });
+    appendHistory(line);
+  }, []);
+  const handleSlashCommand = useCallback3(
+    (input) => {
+      const trimmed = input.trim();
+      if (!trimmed.startsWith("/")) return false;
+      const spaceIdx = trimmed.indexOf(" ", 1);
+      const cmd = spaceIdx === -1 ? trimmed.slice(1).toLowerCase() : trimmed.slice(1, spaceIdx).toLowerCase();
+      const arg = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1).trim();
+      switch (cmd) {
+        // ---- /help ----
+        case "help":
+        case "h":
+        case "?": {
+          agent.addSystemMessage(HELP_TEXT);
+          break;
         }
-        info("Tool call", { tool: name, input: JSON.stringify(input).slice(0, 200) });
-        printToolCall(name, input);
-        agentState = "tool_executing";
-        const result = await td.execute(input);
-        agentState = "streaming";
-        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-        debug("Tool result", { tool: name, result: resultStr.slice(0, 200) });
-        printToolResult(name, resultStr);
-        return result;
-      }
-    };
-  }
-  info("Session started", { provider, model: modelName, workingDir, trustAll });
-  initTerminal();
-  printHeader("0.1.0", provider, modelName, workingDir);
-  const statusText = printStatusBar(provider, modelName, 0, planMode ? "PLAN" : trustAll ? "trust all" : "ask", 0);
-  setStatusBar(statusText);
-  const rl = readline2.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: chalk3.cyan("\u276F "),
-    completer
-  });
-  function promptWithStatus() {
-    showStatusBar();
-    rl.prompt();
-  }
-  const history = loadHistory();
-  rl.history = history.reverse();
-  permissions.setReadline(rl);
-  process.on("SIGINT", () => {
-    if (agentState === "streaming") {
-      if (currentAbortController)
-        currentAbortController.abort();
-      console.log(chalk3.yellow("\n  [cancelled]"));
-      agentState = "idle";
-      currentAbortController = null;
-      processing = false;
-      rl.resume();
-      promptWithStatus();
-    } else if (agentState === "tool_executing") {
-      console.log(chalk3.yellow("\n  [cancelling...]"));
-      killActiveProcess();
-      if (currentAbortController)
-        currentAbortController.abort();
-      agentState = "idle";
-      currentAbortController = null;
-      processing = false;
-      rl.resume();
-      promptWithStatus();
-    } else if (agentState === "permission_waiting") {
-      permissions.cancelPrompt();
-      console.log(chalk3.yellow("\n  [cancelled]"));
-      agentState = "idle";
-      currentAbortController = null;
-      processing = false;
-      rl.resume();
-      promptWithStatus();
-    } else {
-      const now = Date.now();
-      if (now - lastCtrlCTime < 500) {
-        saveSession(session);
-        exitTerminal();
-        console.log(chalk3.dim("  Goodbye!"));
-        process.exit(0);
-      }
-      lastCtrlCTime = now;
-      console.log(chalk3.dim("\n  Press Ctrl+C again to exit."));
-      promptWithStatus();
-    }
-  });
-  const systemPrompt = `You are WorkerMill, an AI coding agent running in the user's terminal.
-You have access to tools for reading, writing, and editing files, running bash commands, searching code, and fetching web content.
+        // ---- /model ----
+        case "model": {
+          agent.addSystemMessage(
+            `**Current model:** ${props.provider}/${props.model}
 
-Working directory: ${workingDir}
+**Supported model families:**
+- Anthropic: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5
+- OpenAI: gpt-5.4, gpt-5.4-mini
+- Google: gemini-3.1-pro, gemini-3.1-flash-lite
+- Ollama: any locally-hosted model
 
-Guidelines:
-- Be concise and direct in your responses
-- Use tools proactively to explore the codebase before making changes
-- When editing files, read them first to understand context
-- Prefer editing existing files over creating new ones
-- Run tests after making changes when test infrastructure exists
-- Use glob and grep to find relevant files before reading them
-
-Focus on writing clean, production-ready code.`;
-  promptWithStatus();
-  let processing = false;
-  let multilineBacktick = false;
-  let multilineBackslash = false;
-  let multilineBuffer = [];
-  const cmdCtx = {
-    config,
-    session,
-    costTracker,
-    workingDir,
-    planMode,
-    setPlanMode: (mode) => {
-      planMode = mode;
-      cmdCtx.planMode = mode;
-    },
-    processInput
-  };
-  function processInput(input) {
-    processing = true;
-    rl.pause();
-    (async () => {
-      try {
-        addMessage(session, "user", input);
-        appendHistory(input);
-        if (!session.name) {
-          session.name = input.slice(0, 50).replace(/\n/g, " ");
+To change: edit \`~/.workermill/cli.json\` or restart with \`--provider\` / \`--model\` flags.`
+          );
+          break;
         }
-        info("User message", { length: input.length, preview: input.slice(0, 100) });
-        if (session.messages.length <= 1) {
-          const { classifyComplexity, runOrchestration } = await import("./orchestrator-NMTZUS23.js");
-          console.log(chalk3.dim("\n  Analyzing task complexity..."));
-          info("Running complexity classifier");
-          const classification = await classifyComplexity(config, input);
-          info("Classification result", { isMulti: classification.isMulti, reason: classification.reason });
-          if (classification.isMulti) {
-            console.log(chalk3.dim(`  \u2192 multi-expert (${classification.reason})
-`));
-            await runOrchestration(config, input, trustAll, sandboxed, rl);
-            processing = false;
-            rl.resume();
-            promptWithStatus();
-            return;
+        // ---- /cost ----
+        case "cost": {
+          const costUsd = agent.cost;
+          const totalTokens = agent.tokens;
+          const sessionMessages = agent.session.messages.length;
+          agent.addSystemMessage(
+            `**Session Cost Summary**
+
+| Metric | Value |
+|---|---|
+| Model | ${props.provider}/${props.model} |
+| Total cost | $${costUsd.toFixed(4)} |
+| Last input tokens | ${totalTokens.toLocaleString()} |
+| Session tokens | ${agent.session.totalTokens.toLocaleString()} |
+| Messages | ${sessionMessages} |`
+          );
+          break;
+        }
+        // ---- /status ----
+        case "status": {
+          const session = agent.session;
+          const msgCount = session.messages.length;
+          const mode = props.planMode ? "PLAN (read-only)" : props.trustAll ? "TRUST ALL" : "ask";
+          agent.addSystemMessage(
+            `**Session Status**
+
+| Field | Value |
+|---|---|
+| Session ID | \`${session.id.slice(0, 8)}...\` |
+| Provider / Model | ${props.provider}/${props.model} |
+| Messages | ${msgCount} |
+| Session tokens | ${session.totalTokens.toLocaleString()} |
+| Cost | $${agent.cost.toFixed(4)} |
+| Mode | ${mode} |
+| Working dir | \`${props.workingDir}\` |
+| Started | ${session.startedAt} |`
+          );
+          break;
+        }
+        // ---- /plan ----
+        case "plan": {
+          const newPlan = !props.planMode;
+          agent.setPlanMode(newPlan);
+          agent.addSystemMessage(
+            newPlan ? "**Plan mode ON.** Only read-only tools (read_file, glob, grep, ls, sub_agent) are available. Write operations are blocked." : "**Plan mode OFF.** All tools are now available."
+          );
+          break;
+        }
+        // ---- /trust ----
+        case "trust": {
+          agent.setTrustAll(true);
+          agent.addSystemMessage(
+            "**Trust mode ON.** All non-dangerous tool calls will be auto-approved for this session. Dangerous operations (force push, rm -rf, etc.) still require confirmation."
+          );
+          break;
+        }
+        // ---- /build <task> ----
+        case "build": {
+          if (!arg) {
+            agent.addSystemMessage(
+              "**Usage:** `/build <task description>`\n\nRuns WorkerMill multi-expert orchestration: classifies complexity, plans stories, executes per-persona with tool calls, reviews, and revision loops."
+            );
+          } else if (orchestrator.running) {
+            agent.addSystemMessage("Orchestration is already running. Wait for it to complete.");
           } else {
-            console.log(chalk3.dim(`  \u2192 single agent (${classification.reason})
-`));
+            agent.addUserMessage(`/build ${arg}`);
+            orchestrator.start(arg, props.trustAll, props.sandboxed);
           }
+          break;
         }
-        info("Starting streamText", { model: modelName, messageCount: session.messages.length });
-        const thinkingSpinner = ora2({ stream: process.stdout, text: chalk3.dim("Thinking..."), prefixText: " " }).start();
-        currentAbortController = new AbortController();
-        const timeoutId = setTimeout(() => currentAbortController?.abort(), 10 * 60 * 1e3);
-        agentState = "streaming";
-        const stream = streamText({
-          model,
-          system: systemPrompt,
-          messages: session.messages.map((m) => ({
-            role: m.role,
-            content: m.content
-          })),
-          tools: getActiveTools(),
-          stopWhen: stepCountIs(100),
-          abortSignal: currentAbortController.signal
-        });
-        let fullText = "";
-        let spinnerStopped = false;
-        for await (const chunk of stream.textStream) {
-          if (!spinnerStopped) {
-            thinkingSpinner.stop();
-            spinnerStopped = true;
-            process.stdout.write("\n");
+        // ---- /clear ----
+        case "clear": {
+          agent.addSystemMessage(
+            "Screen clearing is not fully supported in the Ink terminal framework. Previous messages rendered via `Static` cannot be removed. The conversation continues below."
+          );
+          break;
+        }
+        // ---- /compact ----
+        case "compact": {
+          const inputTokens = agent.tokens;
+          if (inputTokens > 0) {
+            agent.addSystemMessage(
+              `Compaction is triggered automatically when context usage exceeds 80%. Current last-observed input tokens: ${inputTokens.toLocaleString()}. To force compaction, send a message and the agent will evaluate context pressure.`
+            );
+          } else {
+            agent.addSystemMessage(
+              "No token usage recorded yet. Compaction happens automatically when context usage exceeds 80% of the model limit."
+            );
           }
-          process.stdout.write(chalk3.white(chunk));
-          fullText += chunk;
+          break;
         }
-        clearTimeout(timeoutId);
-        agentState = "idle";
-        currentAbortController = null;
-        if (!spinnerStopped) {
-          thinkingSpinner.stop();
-          process.stdout.write("\n");
+        // ---- /git ----
+        case "git": {
+          const gitInfo = getGitStatus(props.workingDir);
+          agent.addSystemMessage(gitInfo);
+          break;
         }
-        if (fullText.trim()) {
-          process.stdout.write("\n");
+        // ---- /editor ----
+        case "editor": {
+          const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+          const tmpFile = path2.join(os.tmpdir(), `workermill-${Date.now()}.md`);
+          try {
+            fs2.writeFileSync(tmpFile, "", "utf-8");
+            execSync2(`${editor} ${tmpFile}`, {
+              cwd: props.workingDir,
+              stdio: "inherit",
+              timeout: 5 * 60 * 1e3
+            });
+            const contents = fs2.readFileSync(tmpFile, "utf-8").trim();
+            if (contents) {
+              agent.addUserMessage(contents);
+              agent.submit(contents);
+            } else {
+              agent.addSystemMessage("Editor closed with no content. Nothing submitted.");
+            }
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            agent.addSystemMessage(`Failed to open editor (\`${editor}\`): ${errMsg}`);
+          } finally {
+            try {
+              fs2.unlinkSync(tmpFile);
+            } catch {
+            }
+          }
+          break;
         }
-        const usage = await stream.totalUsage;
-        const tokens = (usage?.inputTokens || 0) + (usage?.outputTokens || 0);
-        session.totalTokens += tokens;
-        costTracker.addUsage("agent", provider, modelName, usage?.inputTokens || 0, usage?.outputTokens || 0);
-        const finalText = await stream.text;
-        info("Response complete", { tokens, textLength: finalText.length });
-        addMessage(session, "assistant", finalText);
-        saveSession(session);
-        const compactionLevel = shouldCompact(session.totalTokens, modelName);
-        if (compactionLevel !== "none") {
-          const spinner = ora2({ stream: process.stdout, text: `Compacting conversation (${compactionLevel})...`, prefixText: "  " }).start();
-          const plainMessages = session.messages.map((m) => ({ role: m.role, content: m.content }));
-          const compacted = await compactMessages(model, plainMessages, compactionLevel);
-          session.messages = compacted.map((m) => ({
-            role: m.role,
-            content: m.content,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }));
-          saveSession(session);
-          spinner.succeed("Conversation compacted");
+        // ---- /sessions ----
+        case "sessions": {
+          const sessions = listSessions(20);
+          if (sessions.length === 0) {
+            agent.addSystemMessage("No saved sessions found.");
+          } else {
+            const rows = sessions.map((s) => {
+              const date = new Date(s.startedAt).toLocaleString();
+              const name = s.name || s.preview;
+              return `| \`${s.id.slice(0, 8)}\` | ${name} | ${s.messageCount} msgs | ${s.totalTokens.toLocaleString()} tokens | ${date} |`;
+            });
+            agent.addSystemMessage(
+              `**Recent Sessions** (${sessions.length})
+
+| ID | Name | Messages | Tokens | Date |
+|---|---|---|---|---|
+` + rows.join("\n")
+            );
+          }
+          break;
         }
-        const bar = printStatusBar(provider, modelName, session.totalTokens, planMode ? "PLAN" : trustAll ? "trust all" : "ask", costTracker.getTotalCost());
-        setStatusBar(bar);
-      } catch (err) {
-        agentState = "idle";
-        currentAbortController = null;
-        if (err instanceof Error && err.name === "AbortError") {
-        } else {
-          error("Agent error", { error: err instanceof Error ? err.message : String(err) });
-          printError(err instanceof Error ? err.message : String(err));
+        // ---- /quit, /exit ----
+        case "quit":
+        case "exit":
+        case "q": {
+          exit();
+          break;
+        }
+        // ---- Unknown slash command ----
+        default: {
+          agent.addSystemMessage(
+            `Unknown command: \`/${cmd}\`
+
+Type \`/help\` to see all available commands.`
+          );
+          break;
         }
       }
-      processing = false;
-      rl.resume();
-      promptWithStatus();
-    })();
-  }
-  rl.on("line", (input) => {
-    if (permissions.questionActive)
-      return;
-    if (input.trim() === "```" && !multilineBacktick && !multilineBackslash) {
-      multilineBacktick = true;
-      multilineBuffer = [];
-      process.stdout.write(chalk3.dim("  ... "));
-      return;
-    }
-    if (input.trim() === "```" && multilineBacktick) {
-      multilineBacktick = false;
-      const fullInput = multilineBuffer.join("\n");
-      multilineBuffer = [];
-      if (!fullInput.trim() || processing) {
-        rl.prompt();
-        return;
+      return true;
+    },
+    [agent, props, exit]
+  );
+  const handleShellEscape = useCallback3(
+    (input) => {
+      if (!input.startsWith("!")) return false;
+      const bashCmd = input.slice(1).trim();
+      if (!bashCmd) {
+        agent.addSystemMessage("Usage: `!<command>` -- run a shell command and display the output.");
+        return true;
       }
-      processInput(fullInput);
-      return;
-    }
-    if (multilineBacktick) {
-      multilineBuffer.push(input);
-      process.stdout.write(chalk3.dim("  ... "));
-      return;
-    }
-    if (input.endsWith("\\") && !input.endsWith("\\\\")) {
-      if (!multilineBackslash) {
-        multilineBackslash = true;
-        multilineBuffer = [input.slice(0, -1)];
+      let output;
+      let exitCode = 0;
+      try {
+        output = execSync2(bashCmd, {
+          cwd: props.workingDir,
+          encoding: "utf-8",
+          timeout: 3e4,
+          maxBuffer: 1024 * 1024
+        });
+      } catch (err) {
+        const execErr = err;
+        output = (execErr.stdout || "") + (execErr.stderr || "");
+        exitCode = execErr.status ?? 1;
+      }
+      const trimmedOutput = output.trim();
+      const header = exitCode !== 0 ? `\`$ ${bashCmd}\` (exit ${exitCode})` : `\`$ ${bashCmd}\``;
+      if (trimmedOutput) {
+        agent.addSystemMessage(`${header}
+
+\`\`\`
+${trimmedOutput}
+\`\`\``);
       } else {
-        multilineBuffer.push(input.slice(0, -1));
+        agent.addSystemMessage(`${header}
+
+(no output)`);
       }
-      process.stdout.write(chalk3.dim("  ... "));
-      return;
-    }
-    if (multilineBackslash) {
-      multilineBackslash = false;
-      multilineBuffer.push(input);
-      const fullInput = multilineBuffer.join("\n");
-      multilineBuffer = [];
-      if (!fullInput.trim() || processing) {
-        rl.prompt();
+      return true;
+    },
+    [agent, props.workingDir]
+  );
+  const handleSubmit = useCallback3(
+    (input) => {
+      const trimmed = input.trim();
+      if (!trimmed) return;
+      pushHistory(trimmed);
+      if (handleSlashCommand(trimmed)) {
         return;
       }
-      processInput(fullInput);
-      return;
-    }
-    const trimmed = input.trim();
-    if (!trimmed || processing) {
-      if (!processing)
-        rl.prompt();
-      return;
-    }
-    if (trimmed.startsWith("!")) {
-      const cmd = trimmed.slice(1).trim();
-      if (cmd) {
-        try {
-          const output = execSync3(cmd, { cwd: workingDir, encoding: "utf-8", timeout: 3e4 });
-          if (output.trim())
-            console.log(output);
-        } catch (err) {
-          console.log(chalk3.red(err.stderr || err.message));
-        }
+      if (handleShellEscape(trimmed)) {
+        return;
       }
-      rl.prompt();
-      return;
-    }
-    if (trimmed.startsWith("/")) {
-      processing = true;
-      rl.pause();
-      handleCommand(trimmed, cmdCtx).then(() => {
-        processing = false;
-        rl.resume();
-        promptWithStatus();
-      });
-      return;
-    }
-    processInput(trimmed);
-  });
-  rl.on("close", () => {
-    info("Session ended", { totalTokens: session.totalTokens, messages: session.messages.length });
-    flush();
-    const cleanup = () => {
-      saveSession(session);
-      exitTerminal();
-      console.log(chalk3.dim("  Goodbye!"));
-      process.exit(0);
-    };
-    if (processing) {
-      const checkDone = setInterval(() => {
-        if (!processing) {
-          clearInterval(checkDone);
-          cleanup();
-        }
-      }, 500);
-    } else {
-      cleanup();
+      refreshGitBranch();
+      agent.submit(trimmed);
+    },
+    [agent, pushHistory, handleSlashCommand, handleShellEscape, refreshGitBranch]
+  );
+  return /* @__PURE__ */ jsx7(
+    App,
+    {
+      provider: props.provider,
+      model: props.model,
+      workingDir: props.workingDir,
+      maxContext: props.contextLength || 128e3,
+      trustAll: props.trustAll,
+      planMode: props.planMode,
+      onSubmit: handleSubmit,
+      messages: agent.messages,
+      status: orchestrator.running ? "tool_running" : agent.status,
+      permissionRequest: agent.permissionRequest,
+      orchestratorConfirm: orchestrator.confirmRequest,
+      orchestratorStatus: orchestrator.statusMessage,
+      tokens: agent.tokens,
+      cost: agent.cost,
+      gitBranch,
+      inputHistory
     }
-  });
+  );
 }
 
 // src/index.ts
-var VERSION = "0.1.7";
-var program = new Command().name("workermill").description("AI coding agent with multi-expert orchestration").version(VERSION).option("--provider <provider>", "Override default provider").option("--model <model>", "Override model").option("--trust", "Skip all tool permission prompts").option("--resume", "Resume the last conversation").option("--plan", "Start in plan mode (read-only tools)").option("--auto-revise", "Auto-revise on failed reviews without prompting").option("--max-revisions <n>", "Max review\u2192revise cycles (default: 2)", parseInt).option("--critic", "Run separate critic pass on plan before execution").option("--full-disk", "Allow tools to access files outside working directory (default: restricted to cwd)").action(async (options) => {
+var VERSION = "0.2.0";
+var program = new Command().name("workermill").description("AI coding agent with multi-provider support").version(VERSION).option("--provider <provider>", "Override default provider").option("--model <model>", "Override model").option("--trust", "Skip all tool permission prompts").option("--resume", "Resume the last conversation").option("--plan", "Start in plan mode (read-only tools)").option("--full-disk", "Allow tools to access files outside working directory").action(async (options) => {
   let config = loadConfig();
   if (!config) {
     config = await runSetup();
@@ -957,15 +1967,22 @@ var program = new Command().name("workermill").description("AI coding agent with
       providerConfig.model = options.model;
     }
   }
-  if (options.autoRevise || options.maxRevisions || options.critic) {
-    config.review = {
-      ...config.review,
-      ...options.autoRevise ? { autoRevise: true } : {},
-      ...options.maxRevisions ? { maxRevisions: options.maxRevisions } : {},
-      ...options.critic ? { useCritic: true } : {}
-    };
-  }
-  const fullDisk = options.fullDisk || false;
-  await runAgent(config, options.trust || false, options.resume || false, options.plan || false, fullDisk);
+  const { provider, model, apiKey, host, contextLength } = getProviderForPersona(config);
+  const workingDir = process.cwd();
+  const { waitUntilExit } = render(
+    React5.createElement(Root, {
+      provider,
+      model,
+      apiKey,
+      host,
+      contextLength,
+      trustAll: options.trust || false,
+      planMode: options.plan || false,
+      sandboxed: !options.fullDisk,
+      resume: options.resume || false,
+      workingDir
+    })
+  );
+  await waitUntilExit();
 });
 program.parse();