@robota-sdk/agent-cli 3.0.0-beta.54 → 3.0.0-beta.56

package/dist/node/chunk-H3NRW5FW.js

@@ -0,0 +1,4372 @@
+import {
+  DEFAULT_PROVIDER_DEFINITIONS,
+  createProviderFromSettings,
+  findProviderDefinition,
+  formatSupportedProviderTypes,
+  isSubagentWorkerChildMessage,
+  readMergedProviderSettings,
+  readProviderSettings
+} from "./chunk-2JAZDNYT.js";
+
+// src/background/managed-shell-process-runner.ts
+import { spawn } from "child_process";
+import {
+  BackgroundTaskError
+} from "@robota-sdk/agent-sdk";
+var DEFAULT_OUTPUT_LIMIT_BYTES = 3e4;
+var DEFAULT_KILL_GRACE_MS = 2e3;
+var LOG_PAGE_SIZE = 200;
+function createCapture(limitBytes) {
+  const chunks = [];
+  let capturedBytes = 0;
+  let truncated = false;
+  return {
+    appendOutput(text) {
+      if (truncated) return;
+      const remaining = limitBytes - capturedBytes;
+      const buffer = Buffer.from(text, "utf8");
+      if (buffer.byteLength <= remaining) {
+        chunks.push(text);
+        capturedBytes += buffer.byteLength;
+        return;
+      }
+      chunks.push(buffer.subarray(0, Math.max(remaining, 0)).toString("utf8"));
+      chunks.push("\n[output truncated]\n");
+      truncated = true;
+    },
+    getOutput() {
+      return chunks.join("");
+    }
+  };
+}
+function appendLog(lines, source, text) {
+  for (const line of text.split(/\r?\n/)) {
+    if (line.length > 0) lines.push(`[${source}] ${line}`);
+  }
+}
+function resolveShell(request) {
+  return { command: request.shell ?? "sh", args: ["-c", request.command] };
+}
+function sendInput(child, input) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      child.stdin.off("error", onError);
+      reject(error);
+    };
+    child.stdin.once("error", onError);
+    child.stdin.end(input, () => {
+      child.stdin.off("error", onError);
+      resolve();
+    });
+  });
+}
+function createManagedShellProcessRunner(options = {}) {
+  const killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+  return {
+    kind: "process",
+    start(task) {
+      if (task.request.kind !== "process") {
+        throw new BackgroundTaskError("runner", `Invalid process task kind: ${task.request.kind}`);
+      }
+      return startProcessTask(task.taskId, task.request, killGraceMs);
+    }
+  };
+}
+function startProcessTask(taskId, request, killGraceMs) {
+  const shell = resolveShell(request);
+  const runtime = {
+    taskId,
+    request,
+    child: spawn(shell.command, shell.args, {
+      cwd: request.cwd,
+      env: { ...process.env, ...request.env ?? {} },
+      stdio: ["pipe", "pipe", "pipe"]
+    }),
+    logs: [],
+    capture: createCapture(request.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES),
+    killGraceMs
+  };
+  const result = createProcessResult(runtime);
+  return createProcessHandle(runtime, result);
+}
+function createProcessResult(runtime) {
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    const timeoutTimer = runtime.request.timeoutMs ? setTimeout(() => {
+      appendLog(runtime.logs, "system", `timed out after ${runtime.request.timeoutMs}ms`);
+      runtime.child.kill("SIGTERM");
+      rejectOnceLocal(new BackgroundTaskError("timeout", "Background process timed out"));
+    }, runtime.request.timeoutMs) : void 0;
+    function clearTimers() {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      if (runtime.killTimer) clearTimeout(runtime.killTimer);
+    }
+    function resolveOnce(exitCode, signalCode) {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      resolve({
+        taskId: runtime.taskId,
+        kind: "process",
+        output: runtime.capture.getOutput(),
+        exitCode,
+        signalCode
+      });
+    }
+    function rejectOnceLocal(error) {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      reject(error);
+    }
+    attachOutputListeners(runtime);
+    runtime.child.on("error", (error) => {
+      appendLog(runtime.logs, "system", error.message);
+      rejectOnceLocal(new BackgroundTaskError("process", error.message));
+    });
+    runtime.child.on("close", (code, signal) => {
+      resolveOnce(code ?? void 0, signal ?? void 0);
+    });
+    if (runtime.request.stdin) {
+      runtime.child.stdin.write(runtime.request.stdin);
+      runtime.child.stdin.end();
+    }
+  });
+}
+function createProcessHandle(runtime, result) {
+  return {
+    taskId: runtime.taskId,
+    ...runtime.child.pid !== void 0 ? { pid: runtime.child.pid } : {},
+    result,
+    cancel: async (reason) => {
+      cancelProcess(runtime, reason);
+    },
+    send: async (input) => {
+      if (!input.stdin) return;
+      await sendInput(runtime.child, input.stdin);
+    },
+    readLog: (cursor) => Promise.resolve(readProcessLog(runtime, cursor))
+  };
+}
+function attachOutputListeners(runtime) {
+  runtime.child.stdout.on("data", (chunk) => {
+    const text = chunk.toString("utf8");
+    runtime.capture.appendOutput(text);
+    appendLog(runtime.logs, "stdout", text);
+  });
+  runtime.child.stderr.on("data", (chunk) => {
+    const text = chunk.toString("utf8");
+    runtime.capture.appendOutput(text);
+    appendLog(runtime.logs, "stderr", text);
+  });
+}
+function cancelProcess(runtime, reason) {
+  appendLog(runtime.logs, "system", reason ? `cancel requested: ${reason}` : "cancel requested");
+  if (!runtime.child.killed) runtime.child.kill("SIGTERM");
+  runtime.killTimer = setTimeout(() => {
+    if (!runtime.child.killed) runtime.child.kill("SIGKILL");
+  }, runtime.killGraceMs);
+}
+function readProcessLog(runtime, cursor) {
+  const offset = cursor?.offset ?? 0;
+  const nextOffset = Math.min(offset + LOG_PAGE_SIZE, runtime.logs.length);
+  return {
+    taskId: runtime.taskId,
+    cursor,
+    nextCursor: nextOffset < runtime.logs.length ? { offset: nextOffset } : void 0,
+    lines: runtime.logs.slice(offset, nextOffset)
+  };
+}
+
+// src/subagents/git-worktree-isolation-adapter.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import {
+  BackgroundTaskError as BackgroundTaskError2
+} from "@robota-sdk/agent-sdk";
+var WORKTREE_DIR = ".robota/worktrees";
+var BRANCH_PREFIX = "robota";
+var GIT_ENCODING = "utf8";
+var SHORT_ID_LENGTH = 8;
+function createGitWorktreeIsolationAdapter(options) {
+  return new GitWorktreeIsolationAdapter(options);
+}
+var GitWorktreeIsolationAdapter = class {
+  worktreeDir;
+  branchPrefix;
+  constructor(options = {}) {
+    this.worktreeDir = options.worktreeDir ?? WORKTREE_DIR;
+    this.branchPrefix = options.branchPrefix ?? BRANCH_PREFIX;
+  }
+  prepare(request) {
+    const repoRoot = runGit(request.cwd, ["rev-parse", "--show-toplevel"]).trim();
+    const shortId = randomUUID().slice(0, SHORT_ID_LENGTH);
+    const branchName = `${this.branchPrefix}/${request.jobId}-${shortId}`;
+    const worktreeRoot = join(repoRoot, this.worktreeDir);
+    const worktreePath = join(worktreeRoot, `${request.jobId}-${shortId}`);
+    mkdirSync(worktreeRoot, { recursive: true });
+    runGit(repoRoot, ["worktree", "add", "-b", branchName, worktreePath, "HEAD"]);
+    return { repoRoot, worktreePath, branchName };
+  }
+  isClean(worktree) {
+    return runGit(worktree.worktreePath, ["status", "--porcelain"]).trim().length === 0;
+  }
+  remove(worktree) {
+    runGit(worktree.repoRoot, ["worktree", "remove", "--force", worktree.worktreePath]);
+    runGit(worktree.repoRoot, ["branch", "-D", worktree.branchName]);
+  }
+};
+function runGit(cwd, args) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: GIT_ENCODING,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BackgroundTaskError2("runner", `git ${args.join(" ")} failed: ${message}`);
+  }
+}
+
+// src/subagents/child-process-subagent-runner.ts
+import { fork } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+import {
+  BackgroundTaskError as BackgroundTaskError5,
+  getBuiltInAgent,
+  createWorktreeSubagentRunner
+} from "@robota-sdk/agent-sdk";
+
+// src/subagents/child-process-subagent-runner-result.ts
+import {
+  BackgroundTaskError as BackgroundTaskError4
+} from "@robota-sdk/agent-sdk";
+
+// src/subagents/child-process-subagent-transport.ts
+import {
+  BackgroundTaskError as BackgroundTaskError3
+} from "@robota-sdk/agent-sdk";
+function handleWorkerMessage(message, startWorker, resolveOnce, rejectOnce, emit) {
+  switch (message.type) {
+    case "ready":
+      startWorker();
+      break;
+    case "result":
+      resolveOnce(message.output);
+      break;
+    case "error":
+      rejectOnce(new BackgroundTaskError3("runner", message.message));
+      break;
+    case "cancelled":
+      rejectOnce(new BackgroundTaskError3("runner", message.reason ?? "Subagent worker cancelled"));
+      break;
+    case "text_delta":
+      emit?.({ type: "background_task_text_delta", delta: message.delta });
+      break;
+    case "tool_start":
+      emit?.({
+        type: "background_task_tool_start",
+        toolName: message.toolName,
+        firstArg: extractFirstArg(message.toolArgs)
+      });
+      break;
+    case "tool_end":
+      emit?.({
+        type: "background_task_tool_end",
+        toolName: message.toolName,
+        success: message.success
+      });
+      break;
+    default:
+      rejectOnce(new BackgroundTaskError3("runner", "Unhandled subagent worker message"));
+  }
+}
+function extractFirstArg(toolArgs) {
+  if (!toolArgs) return void 0;
+  const firstValue = Object.values(toolArgs)[0];
+  if (firstValue === void 0) return void 0;
+  return typeof firstValue === "object" ? JSON.stringify(firstValue) : String(firstValue);
+}
+function sendWorkerMessage(child, message) {
+  return new Promise((resolve, reject) => {
+    if (!child.connected) {
+      reject(new BackgroundTaskError3("crash", "Subagent worker IPC channel is closed"));
+      return;
+    }
+    child.send(message, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function cancelChildProcess(runtime, reason) {
+  if (runtime.child.connected) {
+    await sendWorkerMessage(runtime.child, { type: "cancel", reason }).catch(() => void 0);
+  }
+  runtime.killTimer = setTimeout(() => {
+    if (!runtime.child.killed) {
+      runtime.child.kill("SIGTERM");
+    }
+  }, runtime.killGraceMs);
+}
+
+// src/subagents/child-process-subagent-runner-result.ts
+function createChildProcessSubagentResult(options) {
+  return new Promise((resolve, reject) => {
+    new ChildProcessSubagentResultController(options, resolve, reject).start();
+  });
+}
+var ChildProcessSubagentResultController = class {
+  constructor(options, resolve, reject) {
+    this.options = options;
+    this.resolve = resolve;
+    this.reject = reject;
+    this.timeoutTimer = createTimeoutTimer(this.options.runtime, (error) => this.rejectOnce(error));
+  }
+  settled = false;
+  started = false;
+  timeoutTimer;
+  start() {
+    const { child } = this.options.runtime;
+    child.on("message", this.onMessage);
+    child.on("error", this.onError);
+    child.on("exit", this.onExit);
+    child.once("spawn", () => {
+      setImmediate(this.startWorker);
+    });
+  }
+  startWorker = () => {
+    if (this.started) return;
+    this.started = true;
+    const { child } = this.options.runtime;
+    void sendWorkerMessage(child, { type: "start", payload: this.options.payload }).catch(
+      (error) => {
+        this.rejectOnce(error instanceof Error ? error : new Error(String(error)));
+      }
+    );
+  };
+  onMessage = (message) => {
+    if (!isSubagentWorkerChildMessage(message)) {
+      this.rejectOnce(
+        new BackgroundTaskError4("runner", "Received malformed subagent worker message")
+      );
+      return;
+    }
+    const { job } = this.options.runtime;
+    handleWorkerMessage(message, this.startWorker, this.resolveOnce, this.rejectOnce, job.emit);
+  };
+  onError = (error) => {
+    this.rejectOnce(new BackgroundTaskError4("crash", error.message));
+  };
+  onExit = (code, signal) => {
+    if (this.settled) return;
+    this.rejectOnce(new BackgroundTaskError4("crash", formatEarlyExitMessage(code, signal)));
+  };
+  resolveOnce = (output) => {
+    if (this.settled) return;
+    this.settled = true;
+    this.clearTimers();
+    this.cleanup();
+    const { runtime, resolveTranscriptPath } = this.options;
+    this.resolve(toSubagentResult(runtime.job, output, resolveTranscriptPath));
+  };
+  rejectOnce = (error) => {
+    if (this.settled) return;
+    this.settled = true;
+    this.clearTimers();
+    this.cleanup();
+    this.reject(error);
+  };
+  clearTimers() {
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    if (this.options.runtime.killTimer) clearTimeout(this.options.runtime.killTimer);
+  }
+  cleanup() {
+    const { child } = this.options.runtime;
+    child.off("message", this.onMessage);
+    child.off("error", this.onError);
+    child.off("exit", this.onExit);
+  }
+};
+function createCancellationResult(jobId) {
+  let settled = false;
+  let rejectFn = () => {
+  };
+  const promise = new Promise((_resolve, reject) => {
+    rejectFn = reject;
+  });
+  return {
+    promise,
+    reject(reason) {
+      if (settled) return;
+      settled = true;
+      rejectFn(new BackgroundTaskError4("runner", reason ?? `Subagent job cancelled: ${jobId}`));
+    }
+  };
+}
+function createTimeoutTimer(runtime, rejectOnce) {
+  if (!runtime.job.request.timeoutMs) return void 0;
+  return setTimeout(() => {
+    void cancelChildProcess(runtime, "Subagent worker timed out");
+    rejectOnce(new BackgroundTaskError4("timeout", "Subagent worker timed out"));
+  }, runtime.job.request.timeoutMs);
+}
+function toSubagentResult(job, output, resolveTranscriptPath) {
+  const transcriptPath = resolveTranscriptPath(job);
+  return {
+    jobId: job.jobId,
+    output,
+    ...transcriptPath ? { metadata: { transcriptPath, logPath: transcriptPath } } : {}
+  };
+}
+function formatEarlyExitMessage(code, signal) {
+  const detail = signal !== null ? `signal ${signal}` : `exit code ${code === null ? "unknown" : code}`;
+  return `Subagent worker exited before result: ${detail}`;
+}
+
+// src/subagents/child-process-subagent-runner.ts
+var DEFAULT_KILL_GRACE_MS2 = 2e3;
+var LOG_PAGE_SIZE2 = 200;
+function createChildProcessSubagentRunnerFactory(options = {}) {
+  return (deps) => {
+    const runner = new ChildProcessSubagentRunner(deps, options);
+    if (options.worktreeIsolation === false) return runner;
+    return createWorktreeSubagentRunner({
+      runner,
+      worktreeAdapter: options.worktreeAdapter ?? createGitWorktreeIsolationAdapter(),
+      hooks: deps.config.hooks,
+      hookTypeExecutors: deps.hookTypeExecutors
+    });
+  };
+}
+var ChildProcessSubagentRunner = class {
+  constructor(deps, options = {}) {
+    this.deps = deps;
+    this.workerPath = options.workerPath ?? resolveDefaultWorkerPath();
+    this.execArgv = options.execArgv;
+    this.killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS2;
+    this.providerConfig = options.providerConfig;
+    this.env = options.env;
+    this.logsDir = options.logsDir;
+  }
+  workerPath;
+  execArgv;
+  killGraceMs;
+  providerConfig;
+  env;
+  logsDir;
+  start(job) {
+    const child = fork(this.workerPath, [], {
+      cwd: job.request.cwd,
+      env: { ...process.env, ...this.env ?? {} },
+      execArgv: this.execArgv ?? resolveDefaultExecArgv(this.workerPath),
+      stdio: ["ignore", "ignore", "ignore", "ipc"]
+    });
+    const runtime = {
+      job,
+      child,
+      killGraceMs: this.killGraceMs
+    };
+    const payload = this.createStartPayload(job);
+    const workerResult = createChildProcessSubagentResult({
+      runtime,
+      payload,
+      resolveTranscriptPath: (request) => this.resolveTranscriptPath(request)
+    });
+    const cancellation = createCancellationResult(job.jobId);
+    void workerResult.catch(() => void 0);
+    const result = Promise.race([workerResult, cancellation.promise]);
+    const transcriptPath = this.resolveTranscriptPath(job);
+    return {
+      jobId: job.jobId,
+      ...child.pid !== void 0 && { pid: child.pid },
+      ...transcriptPath !== void 0 && { transcriptPath, logPath: transcriptPath },
+      result,
+      cancel: async (reason) => {
+        cancellation.reject(reason);
+        await cancelChildProcess(runtime, reason);
+      },
+      send: async (prompt) => {
+        await sendWorkerMessage(child, { type: "send", prompt });
+      },
+      ...transcriptPath !== void 0 && {
+        readLog: async (cursor) => readTranscriptLog(job.jobId, transcriptPath, cursor)
+      }
+    };
+  }
+  createStartPayload(job) {
+    const definition = resolveAgentDefinition(job.request.type, this.deps.customAgentRegistry);
+    return {
+      jobId: job.jobId,
+      request: job.request,
+      agentDefinition: applyRequestOverrides(definition, job),
+      parentConfig: this.deps.config,
+      parentContext: this.deps.context,
+      providerProfile: createProviderProfile(this.providerConfig, this.deps, job),
+      permissionMode: this.deps.permissionMode,
+      ...this.logsDir ? { logsDir: this.logsDir } : {}
+    };
+  }
+  resolveTranscriptPath(job) {
+    if (!this.logsDir) return void 0;
+    return join2(this.logsDir, job.request.parentSessionId, "subagents", `${job.jobId}.jsonl`);
+  }
+};
+function resolveAgentDefinition(agentType, customRegistry) {
+  const definition = customRegistry?.(agentType) ?? getBuiltInAgent(agentType);
+  if (!definition) {
+    throw new BackgroundTaskError5("validation", `Unknown agent type: ${agentType}`);
+  }
+  return definition;
+}
+function applyRequestOverrides(definition, job) {
+  return {
+    ...definition,
+    ...job.request.model ? { model: job.request.model } : {},
+    ...job.request.allowedTools ? { tools: job.request.allowedTools } : {},
+    ...job.request.disallowedTools ? { disallowedTools: job.request.disallowedTools } : {}
+  };
+}
+function createProviderProfile(providerConfig, deps, job) {
+  const provider = providerConfig ?? deps.config.provider;
+  return {
+    profileName: deps.config.currentProvider,
+    type: provider.name,
+    model: job.request.model ?? provider.model,
+    apiKey: provider.apiKey,
+    baseURL: provider.baseURL,
+    timeout: provider.timeout
+  };
+}
+function resolveDefaultWorkerPath() {
+  const entryPoint = process.argv[1] ?? "";
+  const entryDir = entryPoint ? dirname(entryPoint) : process.cwd();
+  const extension = entryPoint.endsWith(".ts") || entryPoint.endsWith(".tsx") ? ".ts" : ".js";
+  const candidates = [
+    join2(entryDir, "subagents", `child-process-subagent-worker${extension}`),
+    join2(entryDir, `child-process-subagent-worker${extension}`)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+}
+function resolveDefaultExecArgv(workerPath) {
+  if (!workerPath.endsWith(".ts")) {
+    return process.execArgv;
+  }
+  if (process.execArgv.some((arg) => arg.includes("tsx"))) {
+    return process.execArgv;
+  }
+  return [...process.execArgv, "--import", "tsx"];
+}
+function readTranscriptLog(jobId, transcriptPath, cursor) {
+  const offset = cursor?.offset ?? 0;
+  if (!existsSync(transcriptPath)) {
+    return {
+      taskId: jobId,
+      cursor,
+      lines: []
+    };
+  }
+  const lines = readFileSync(transcriptPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const nextOffset = Math.min(offset + LOG_PAGE_SIZE2, lines.length);
+  return {
+    taskId: jobId,
+    cursor,
+    nextCursor: nextOffset < lines.length ? { offset: nextOffset } : void 0,
+    lines: lines.slice(offset, nextOffset)
+  };
+}
+
+// src/cli.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+import { InteractiveSession as InteractiveSession2, projectPaths } from "@robota-sdk/agent-sdk";
+import { SessionStore } from "@robota-sdk/agent-sessions";
+
+// src/utils/cli-args.ts
+import { parseArgs } from "util";
+var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function parsePermissionMode(raw) {
+  if (raw === void 0) return void 0;
+  if (!VALID_MODES.includes(raw)) {
+    process.stderr.write(`Invalid --permission-mode "${raw}". Valid: ${VALID_MODES.join(" | ")}
+`);
+    process.exit(1);
+  }
+  return raw;
+}
+function parseMaxTurns(raw) {
+  if (raw === void 0) return void 0;
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n <= 0) {
+    process.stderr.write(`Invalid --max-turns "${raw}". Must be a positive integer.
+`);
+    process.exit(1);
+  }
+  return n;
+}
+function parseCliArgs() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      p: { type: "boolean", short: "p", default: false },
+      continue: { type: "boolean", short: "c", default: false },
+      resume: { type: "string", short: "r" },
+      model: { type: "string" },
+      language: { type: "string" },
+      "permission-mode": { type: "string" },
+      "max-turns": { type: "string" },
+      "fork-session": { type: "boolean", default: false },
+      name: { type: "string", short: "n" },
+      "output-format": { type: "string" },
+      "system-prompt": { type: "string" },
+      "append-system-prompt": { type: "string" },
+      version: { type: "boolean", default: false },
+      reset: { type: "boolean", default: false },
+      bare: { type: "boolean", default: false },
+      "allowed-tools": { type: "string" },
+      "no-session-persistence": { type: "boolean", default: false },
+      "json-schema": { type: "string" },
+      configure: { type: "boolean", default: false },
+      "configure-provider": { type: "string" },
+      provider: { type: "string" },
+      type: { type: "string" },
+      "base-url": { type: "string" },
+      "api-key": { type: "string" },
+      "api-key-env": { type: "string" },
+      "set-current": { type: "boolean", default: false },
+      "settings-scope": { type: "string" }
+    }
+  });
+  return {
+    positional: positionals,
+    printMode: values["p"] ?? false,
+    continueMode: values["continue"] ?? false,
+    resumeId: values["resume"],
+    model: values["model"],
+    language: values["language"],
+    permissionMode: parsePermissionMode(values["permission-mode"]),
+    maxTurns: parseMaxTurns(values["max-turns"]),
+    forkSession: values["fork-session"] ?? false,
+    sessionName: values["name"],
+    outputFormat: values["output-format"],
+    systemPrompt: values["system-prompt"],
+    appendSystemPrompt: values["append-system-prompt"],
+    version: values["version"] ?? false,
+    reset: values["reset"] ?? false,
+    bare: values["bare"] ?? false,
+    allowedTools: values["allowed-tools"],
+    noSessionPersistence: values["no-session-persistence"] ?? false,
+    jsonSchema: values["json-schema"],
+    configure: values["configure"] ?? false,
+    configureProvider: values["configure-provider"],
+    provider: values["provider"],
+    providerType: values["type"],
+    baseURL: values["base-url"],
+    apiKey: values["api-key"],
+    apiKeyEnv: values["api-key-env"],
+    setCurrent: values["set-current"] ?? false,
+    settingsScope: values["settings-scope"]
+  };
+}
+
+// src/utils/settings-io.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+function getUserSettingsPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/";
+  return join3(home, ".robota", "settings.json");
+}
+function readSettings(path) {
+  if (!existsSync2(path)) return {};
+  const raw = readFileSync2(path, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    process.stderr.write(`Warning: corrupt settings file at ${path}, resetting to defaults
+`);
+    return {};
+  }
+}
+function writeSettings(path, settings) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+function updateModelInSettings(settingsPath, modelId) {
+  const settings = readSettings(settingsPath);
+  const currentProvider = settings.currentProvider;
+  const providers = settings.providers;
+  if (typeof currentProvider === "string" && isSettingsData(providers)) {
+    const providerMap = providers;
+    providerMap[currentProvider] = {
+      ...isSettingsData(providerMap[currentProvider]) ? providerMap[currentProvider] : {},
+      model: modelId
+    };
+    settings.providers = providerMap;
+  } else {
+    settings.provider = {
+      ...isSettingsData(settings.provider) ? settings.provider : {},
+      model: modelId
+    };
+  }
+  writeSettings(settingsPath, settings);
+}
+function isSettingsData(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+function deleteSettings(path) {
+  if (existsSync2(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+
+// src/utils/provider-setup.ts
+import { join as join4 } from "path";
+import { homedir } from "os";
+
+// src/utils/settings-check.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+function checkSettingsFile(filePath, providerDefinitions = []) {
+  if (!existsSync3(filePath)) return "missing";
+  try {
+    const raw = readFileSync3(filePath, "utf8").trim();
+    if (raw.length === 0) return "incomplete";
+    const parsed = JSON.parse(raw);
+    if (!hasUsableProviderConfig(parsed, providerDefinitions)) return "incomplete";
+    return "valid";
+  } catch {
+    return "corrupt";
+  }
+}
+function hasUsableProviderConfig(settings, providerDefinitions) {
+  if (settings.provider && isUsableProviderProfile(settings.provider.name, settings.provider, providerDefinitions)) {
+    return true;
+  }
+  if (typeof settings.currentProvider !== "string") {
+    return false;
+  }
+  const profile = settings.providers?.[settings.currentProvider];
+  return isUsableProviderProfile(profile?.type, profile, providerDefinitions);
+}
+function isUsableProviderProfile(type, profile, providerDefinitions) {
+  if (!profile) {
+    return false;
+  }
+  if (profile.apiKey) {
+    return true;
+  }
+  if (!type) {
+    return false;
+  }
+  const definition = findProviderDefinition(providerDefinitions, type);
+  if (definition === void 0) {
+    return false;
+  }
+  return definition.requiresApiKey !== true || definition.defaults?.apiKey !== void 0;
+}
+
+// src/utils/provider-settings.ts
+function upsertProviderProfile(settings, profileName, profile) {
+  return {
+    ...settings,
+    providers: {
+      ...settings.providers ?? {},
+      [profileName]: profile
+    }
+  };
+}
+function setCurrentProvider(settings, profileName) {
+  if (!settings.providers?.[profileName]) {
+    throw new Error(`Provider profile "${profileName}" was not found`);
+  }
+  return {
+    ...settings,
+    currentProvider: profileName
+  };
+}
+function validateProviderProfile(profileName, profile, options = {}) {
+  if (!profile.type) {
+    throw new Error(`Provider profile "${profileName}" is missing type`);
+  }
+  if (!profile.model) {
+    throw new Error(`Provider profile "${profileName}" is missing model`);
+  }
+  const definition = findProviderDefinition(options.providerDefinitions ?? [], profile.type);
+  if (definition?.requiresApiKey === true && !profile.apiKey && definition.defaults?.apiKey === void 0) {
+    throw new Error(`Provider profile "${profileName}" is missing apiKey`);
+  }
+}
+function buildProviderSetupPatch(input, options = {}) {
+  const profile = buildProviderProfile(input, options);
+  validateProviderProfile(input.profile, profile, options);
+  return {
+    ...input.setCurrent && { currentProvider: input.profile },
+    providers: {
+      [input.profile]: profile
+    }
+  };
+}
+function buildProviderProfile(input, options = {}) {
+  const defaults = getProviderDefaults(input.type, options.providerDefinitions ?? []);
+  const apiKey = input.apiKeyEnv !== void 0 ? `$ENV:${input.apiKeyEnv}` : input.apiKey ?? defaults.apiKey;
+  const baseURL = input.baseURL ?? defaults.baseURL;
+  return {
+    type: input.type,
+    model: input.model ?? defaults.model,
+    ...apiKey !== void 0 && { apiKey },
+    ...baseURL !== void 0 && { baseURL },
+    ...input.timeout !== void 0 && { timeout: input.timeout }
+  };
+}
+function getProviderDefaults(type, providerDefinitions) {
+  return findProviderDefinition(providerDefinitions, type)?.defaults ?? {};
+}
+function mergeProviderPatch(settings, patch) {
+  const [profileName, profile] = Object.entries(patch.providers)[0] ?? [];
+  if (!profileName || !profile) {
+    return settings;
+  }
+  const withProfile = upsertProviderProfile(settings, profileName, profile);
+  return patch.currentProvider ? setCurrentProvider(withProfile, patch.currentProvider) : withProfile;
+}
+
+// src/utils/provider-configuration.ts
+function readProviderDocument(settingsPath) {
+  return readSettings(settingsPath);
+}
+function applyProviderConfiguration(settingsPath, input, options = {}) {
+  const settings = readProviderDocument(settingsPath);
+  const patch = buildProviderSetupPatch(input, options);
+  const next = mergeProviderPatch(settings, patch);
+  writeSettings(settingsPath, next);
+  return next;
+}
+function applyProviderSwitch(settingsPath, profileName, options = {}) {
+  const settings = readProviderDocument(settingsPath);
+  const hasLocalProfile = settings.providers?.[profileName] !== void 0;
+  const hasKnownProfile = options.knownProviders?.[profileName] !== void 0;
+  const next = hasLocalProfile || hasKnownProfile ? { ...settings, currentProvider: profileName } : setCurrentProvider(settings, profileName);
+  writeSettings(settingsPath, next);
+  return next;
+}
+
+// src/utils/provider-setup-flow.ts
+function createProviderSetupFlow(type, providerDefinitions) {
+  return {
+    type,
+    steps: getProviderSetupSteps(type, providerDefinitions),
+    stepIndex: 0,
+    values: {}
+  };
+}
+function getProviderSetupStep(state) {
+  const step = state.steps[state.stepIndex];
+  if (step === void 0) {
+    throw new Error(`Provider setup step ${state.stepIndex} is out of range`);
+  }
+  return step;
+}
+function submitProviderSetupValue(state, rawValue) {
+  const step = getProviderSetupStep(state);
+  const value = rawValue.trim() || step.defaultValue || "";
+  const validationMessage = validateProviderSetupValue(step, value);
+  if (validationMessage !== void 0) {
+    return { status: "error", state, message: validationMessage };
+  }
+  const nextState = {
+    ...state,
+    stepIndex: state.stepIndex + 1,
+    values: { ...state.values, [step.key]: value }
+  };
+  if (nextState.stepIndex < state.steps.length) {
+    return { status: "next", state: nextState };
+  }
+  return { status: "complete", input: buildProviderSetupInput(nextState) };
+}
+async function runProviderSetupPromptFlow(type, promptInput2, providerDefinitions) {
+  let state = createProviderSetupFlow(type, providerDefinitions);
+  const stepCount = state.steps.length;
+  while (state.stepIndex < stepCount) {
+    const step = getProviderSetupStep(state);
+    const value = await promptInput2(formatProviderSetupPromptLabel(step), step.masked === true);
+    const result = submitProviderSetupValue(state, value);
+    if (result.status === "complete") {
+      return result.input;
+    }
+    if (result.status === "error") {
+      throw new Error(result.message);
+    }
+    state = result.state;
+  }
+  throw new Error("Provider setup flow ended without completion");
+}
+function formatProviderSetupPromptLabel(step) {
+  const suffix = step.defaultValue !== void 0 ? ` (default: ${step.defaultValue})` : "";
+  return `  ${step.title}${suffix}: `;
+}
+function validateProviderSetupValue(step, value) {
+  if (step.required === true && value.length === 0) {
+    return "Required";
+  }
+  return void 0;
+}
+function getProviderSetupSteps(type, providerDefinitions) {
+  const definition = findProviderDefinition(providerDefinitions, type);
+  if (definition === void 0) {
+    throw new Error(
+      `Unknown provider: ${type}. Currently supported: ${formatSupportedProviderTypes(providerDefinitions)}`
+    );
+  }
+  if (definition.setupSteps !== void 0) {
+    return [...definition.setupSteps];
+  }
+  const steps = [
+    {
+      key: "model",
+      title: `${definition.type} model`,
+      defaultValue: definition.defaults?.model,
+      required: definition.defaults?.model === void 0
+    }
+  ];
+  if (definition.defaults?.baseURL !== void 0) {
+    steps.unshift({
+      key: "baseURL",
+      title: `${definition.type} base URL`,
+      defaultValue: definition.defaults.baseURL
+    });
+  }
+  if (definition.requiresApiKey === true) {
+    steps.push({
+      key: "apiKey",
+      title: `${definition.type} API key`,
+      defaultValue: definition.defaults?.apiKey,
+      required: definition.defaults?.apiKey === void 0,
+      masked: true
+    });
+  }
+  return steps;
+}
+function buildProviderSetupInput(state) {
+  return {
+    profile: state.type,
+    type: state.type,
+    model: state.values.model,
+    apiKey: state.values.apiKey,
+    ...state.values.baseURL !== void 0 && { baseURL: state.values.baseURL },
+    setCurrent: true
+  };
+}
+
+// src/utils/provider-setup.ts
+function getSettingsPathForScope(cwd, scope) {
+  if (scope === void 0 || scope === "user") {
+    return getUserSettingsPath();
+  }
+  if (scope === "project-local") {
+    return join4(cwd, ".robota", "settings.local.json");
+  }
+  throw new Error(`Invalid --settings-scope "${scope}". Valid: user | project-local`);
+}
+function handleProviderConfigurationArgs(cwd, args, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  const settingsPath = getSettingsPathForScope(cwd, args.settingsScope);
+  if (args.configureProvider) {
+    applyProviderConfiguration(settingsPath, buildSetupInputFromArgs(args), {
+      providerDefinitions
+    });
+    process.stdout.write(`Provider profile saved to ${settingsPath}
+`);
+    return !args.printMode && args.positional.length === 0;
+  }
+  if (args.provider && args.setCurrent) {
+    applyProviderSwitch(settingsPath, args.provider, {
+      knownProviders: readMergedProviderSettings(cwd).providers
+    });
+    process.stdout.write(`Current provider set to ${args.provider}
+`);
+    return !args.printMode && args.positional.length === 0;
+  }
+  return false;
+}
+async function ensureConfig(cwd, args, promptInput2, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  const checks = getSettingsCheckPaths(cwd).map((path) => ({
+    path,
+    status: checkSettingsFile(path, providerDefinitions)
+  }));
+  if (checks.some((check) => check.status === "valid")) {
+    return;
+  }
+  if (!isInteractiveTerminal()) {
+    throw new Error(formatMissingProviderConfigMessage());
+  }
+  await runInteractiveProviderSetup(cwd, args, promptInput2, providerDefinitions);
+}
+async function runInteractiveProviderSetup(cwd, args, promptInput2, providerDefinitions = DEFAULT_PROVIDER_DEFINITIONS) {
+  const defaultProviderType = providerDefinitions[0]?.type ?? "";
+  const supportedTypes = providerDefinitions.map((definition) => definition.type).join("/");
+  const providerChoice = await promptInput2(`  Provider (${supportedTypes}, default: ${defaultProviderType}): `) || defaultProviderType;
+  const type = parseProviderSetupType(providerChoice);
+  const settingsPath = getSettingsPathForScope(cwd, args.settingsScope);
+  const input = await runProviderSetupPromptFlow(type, promptInput2, providerDefinitions);
+  applyProviderConfiguration(settingsPath, input, {
+    providerDefinitions
+  });
+  const language = await promptInput2("  Response language (ko/en/ja/zh, default: en): ");
+  if (language) {
+    const settings = readSettings(settingsPath);
+    settings.language = language;
+    writeSettings(settingsPath, settings);
+  }
+  process.stdout.write(`
+  Config saved to ${settingsPath}
+
+`);
+}
+function parseProviderSetupType(value) {
+  return value.trim();
+}
+function buildSetupInputFromArgs(args) {
+  const type = args.providerType ?? args.configureProvider;
+  if (!args.configureProvider || !type) {
+    throw new Error("--configure-provider requires a provider profile and --type");
+  }
+  return {
+    profile: args.configureProvider,
+    type,
+    ...args.model !== void 0 && { model: args.model },
+    ...args.apiKey !== void 0 && { apiKey: args.apiKey },
+    ...args.apiKeyEnv !== void 0 && { apiKeyEnv: args.apiKeyEnv },
+    ...args.baseURL !== void 0 && { baseURL: args.baseURL },
+    setCurrent: args.setCurrent
+  };
+}
+function getSettingsCheckPaths(cwd) {
+  return [
+    getUserSettingsPath(),
+    join4(homedir(), ".claude", "settings.json"),
+    join4(cwd, ".robota", "settings.json"),
+    join4(cwd, ".robota", "settings.local.json"),
+    join4(cwd, ".claude", "settings.json"),
+    join4(cwd, ".claude", "settings.local.json")
+  ];
+}
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function formatMissingProviderConfigMessage() {
+  return [
+    "No provider configuration found.",
+    "Run `robota --configure` in an interactive terminal, or configure a provider:",
+    "  robota --configure-provider gemma --type gemma --base-url http://localhost:1234/v1 --model supergemma4-26b-uncensored-v2 --api-key lm-studio --set-current",
+    "  robota --configure-provider openai --type openai --model <openai-compatible-model> --api-key-env OPENAI_API_KEY --set-current"
+  ].join("\n");
+}
+
+// src/cli.ts
+import { createHeadlessTransport } from "@robota-sdk/agent-transport-headless";
+
+// src/ui/render.tsx
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { useState as useState14, useEffect as useEffect4 } from "react";
+import { Box as Box14, Text as Text16, useApp as useApp2, useInput as useInput8 } from "ink";
+import { getModelName as getModelName2, createSystemMessage as createSystemMessage4, messageToHistoryEntry as messageToHistoryEntry4 } from "@robota-sdk/agent-core";
+
+// src/ui/hooks/useInteractiveSession.ts
+import { useState, useRef, useCallback as useCallback2, useEffect } from "react";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+import {
+  InteractiveSession,
+  CommandRegistry,
+  BuiltinCommandSource,
+  SkillCommandSource,
+  PluginCommandSource,
+  BundlePluginLoader
+} from "@robota-sdk/agent-sdk";
+import { createSystemMessage as createSystemMessage2, messageToHistoryEntry as messageToHistoryEntry2 } from "@robota-sdk/agent-core";
+
+// src/ui/background-task-view-model.ts
+var BACKGROUND_PREVIEW_LENGTH = 120;
+var BACKGROUND_PREVIEW_WHITESPACE = /\s+/g;
+var BACKGROUND_PREVIEW_SEPARATOR = " ";
+var SUCCESS_EXIT_CODE = 0;
+function toBackgroundTaskViewModel(state, partialText) {
+  return {
+    id: state.id,
+    kind: state.kind,
+    label: state.label,
+    status: state.status,
+    statusLabel: getBackgroundTaskStatusLabel(state),
+    mode: state.mode,
+    currentAction: state.currentAction,
+    unread: state.unread,
+    preview: trimBackgroundPreview(state.promptPreview ?? state.commandPreview) ?? "",
+    resultPreview: trimBackgroundPreview(state.result?.output ?? partialText),
+    errorPreview: trimBackgroundPreview(state.error?.message),
+    startedAt: state.startedAt,
+    lastActivityAt: state.lastActivityAt,
+    timeoutReason: state.timeoutReason
+  };
+}
+function getBackgroundTaskStatusLabel(state) {
+  if (state.status === "failed" && state.timeoutReason) {
+    if (state.timeoutReason === "idle" || state.timeoutReason === "max_runtime") {
+      return "timed out";
+    }
+    return state.timeoutReason.replace(/_/g, " ");
+  }
+  return state.status;
+}
+function shouldHideAtNextUserTurn(state) {
+  return state.status === "completed" && !state.error && (state.result?.exitCode === void 0 || state.result.exitCode === SUCCESS_EXIT_CODE) && !state.result?.signalCode && !state.worktreePath && !state.branchName;
+}
+function trimBackgroundPreview(value) {
+  if (!value) return void 0;
+  const preview = value.trim().replace(BACKGROUND_PREVIEW_WHITESPACE, BACKGROUND_PREVIEW_SEPARATOR);
+  if (!preview) return void 0;
+  return preview.length > BACKGROUND_PREVIEW_LENGTH ? `${preview.slice(0, BACKGROUND_PREVIEW_LENGTH)}...` : preview;
+}
+
+// src/ui/tui-state-manager.ts
+var MAX_RENDERED_MESSAGES = 100;
+var STREAMING_DEBOUNCE_MS = 300;
+function createDebouncedNotify(notify, ms) {
+  let timer = null;
+  return {
+    schedule() {
+      if (!timer) {
+        timer = setTimeout(() => {
+          timer = null;
+          notify();
+        }, ms);
+      }
+    },
+    flush() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+var TuiStateManager = class {
+  // ── Rendering state ───────────────────────────────────────────
+  history = [];
+  streamingText = "";
+  activeTools = [];
+  isThinking = false;
+  isAborting = false;
+  pendingPrompt = null;
+  contextState = { percentage: 0, usedTokens: 0, maxTokens: 0 };
+  backgroundTasks = [];
+  /** Called after any state change. React hook sets this to trigger re-render. */
+  onChange = null;
+  // ── Internal ──────────────────────────────────────────────────
+  streamBuf = "";
+  backgroundTextBuffers = /* @__PURE__ */ new Map();
+  backgroundTasksHiddenOnNextTurn = /* @__PURE__ */ new Set();
+  debouncedStreamNotify = createDebouncedNotify(() => this.notify(), STREAMING_DEBOUNCE_MS);
+  notify() {
+    this.onChange?.();
+  }
+  // ── Event handlers (InteractiveSession → state) ───────────────
+  onTextDelta = (delta) => {
+    this.streamBuf += delta;
+    this.streamingText = this.streamBuf;
+    this.debouncedStreamNotify.schedule();
+  };
+  onToolStart = (state) => {
+    this.activeTools = [...this.activeTools, state];
+    this.notify();
+  };
+  onToolEnd = (state) => {
+    const idx = this.activeTools.findIndex((t) => t.toolName === state.toolName && t.isRunning);
+    if (idx !== -1) {
+      const updated = [...this.activeTools];
+      updated[idx] = state;
+      this.activeTools = updated;
+    }
+    this.notify();
+  };
+  onThinking = (thinking) => {
+    this.isThinking = thinking;
+    if (thinking) {
+      this.debouncedStreamNotify.flush();
+      this.streamBuf = "";
+      this.streamingText = "";
+      this.activeTools = [];
+    } else {
+      this.isAborting = false;
+    }
+    this.notify();
+  };
+  onComplete = (result) => {
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.contextState = {
+      percentage: result.contextState.usedPercentage,
+      usedTokens: result.contextState.usedTokens,
+      maxTokens: result.contextState.maxTokens
+    };
+    this.notify();
+  };
+  onInterrupted = () => {
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  };
+  onError = () => {
+    this.debouncedStreamNotify.flush();
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  };
+  onBackgroundTaskEvent = (event) => {
+    if ("task" in event) {
+      this.upsertBackgroundTask(event.task);
+      return;
+    }
+    if (event.type === "background_task_closed") {
+      this.backgroundTextBuffers.delete(event.taskId);
+      this.backgroundTasksHiddenOnNextTurn.delete(event.taskId);
+      this.backgroundTasks = this.backgroundTasks.filter((task) => task.id !== event.taskId);
+      this.notify();
+      return;
+    }
+    if (event.type === "background_task_text_delta") {
+      this.appendBackgroundTaskText(event.taskId, event.delta);
+      return;
+    }
+    if (event.type === "background_task_tool_start") {
+      this.updateBackgroundTaskAction(event.taskId, event.firstArg ?? event.toolName);
+      return;
+    }
+    if (event.type === "background_task_tool_end") {
+      this.updateBackgroundTaskAction(event.taskId, event.success ? void 0 : event.error);
+    }
+  };
+  // ── State updates from external sources ───────────────────────
+  /** Sync history from InteractiveSession */
+  syncHistory(entries) {
+    if (entries.length === 0) return;
+    this.history = entries.length > MAX_RENDERED_MESSAGES ? entries.slice(-MAX_RENDERED_MESSAGES) : [...entries];
+    this.notify();
+  }
+  /** Add a single history entry */
+  addEntry(entry) {
+    const updated = [...this.history, entry];
+    this.history = updated.length > MAX_RENDERED_MESSAGES ? updated.slice(-MAX_RENDERED_MESSAGES) : updated;
+    this.notify();
+  }
+  /** Update pending prompt state */
+  setPendingPrompt(prompt) {
+    this.pendingPrompt = prompt;
+    this.notify();
+  }
+  /** Set aborting flag */
+  setAborting(aborting) {
+    this.isAborting = aborting;
+    this.notify();
+  }
+  /** Update context state */
+  setContextState(state) {
+    this.contextState = state;
+    this.notify();
+  }
+  onUserTurnAccepted() {
+    if (this.backgroundTasksHiddenOnNextTurn.size === 0) return;
+    const visible = this.backgroundTasks.filter(
+      (task) => !this.backgroundTasksHiddenOnNextTurn.has(task.id)
+    );
+    this.backgroundTasksHiddenOnNextTurn.clear();
+    if (visible.length === this.backgroundTasks.length) return;
+    this.backgroundTasks = visible;
+    this.notify();
+  }
+  upsertBackgroundTask(state) {
+    const partialText = state.result ? void 0 : this.backgroundTextBuffers.get(state.id);
+    const viewModel = toBackgroundTaskViewModel(state, partialText);
+    const index = this.backgroundTasks.findIndex((task) => task.id === state.id);
+    if (index === -1) {
+      this.backgroundTasks = [...this.backgroundTasks, viewModel];
+    } else {
+      const updated = [...this.backgroundTasks];
+      updated[index] = viewModel;
+      this.backgroundTasks = updated;
+    }
+    if (state.status === "completed" || state.status === "failed" || state.status === "cancelled") {
+      this.backgroundTextBuffers.delete(state.id);
+    }
+    if (shouldHideAtNextUserTurn(state)) {
+      this.backgroundTasksHiddenOnNextTurn.add(state.id);
+    } else {
+      this.backgroundTasksHiddenOnNextTurn.delete(state.id);
+    }
+    this.notify();
+  }
+  appendBackgroundTaskText(taskId, delta) {
+    const nextText = `${this.backgroundTextBuffers.get(taskId) ?? ""}${delta}`;
+    this.backgroundTextBuffers.set(taskId, nextText);
+    this.backgroundTasks = this.backgroundTasks.map(
+      (task) => task.id === taskId ? { ...task, resultPreview: trimBackgroundPreview(nextText) } : task
+    );
+    this.notify();
+  }
+  updateBackgroundTaskAction(taskId, currentAction) {
+    this.backgroundTasks = this.backgroundTasks.map(
+      (task) => task.id === taskId ? { ...task, currentAction } : task
+    );
+    this.notify();
+  }
+};
+
+// src/ui/hooks/useSlashRouting.ts
+import { useCallback } from "react";
+import { randomUUID as randomUUID2 } from "crypto";
+import { createSystemMessage, messageToHistoryEntry } from "@robota-sdk/agent-core";
+
+// src/utils/provider-command.ts
+async function handleProviderCommand(cwd, args, deps = {}) {
+  const settings = readMergedProviderSettings(cwd);
+  const providerDefinitions = deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  const [subcommand = "current", profileArg] = args.trim().split(/\s+/);
+  if (subcommand === "list") {
+    return {
+      message: formatProviderList(settings.currentProvider, settings.providers),
+      success: true
+    };
+  }
+  if (subcommand === "current" || subcommand === "") {
+    return {
+      message: formatCurrentProvider(settings.currentProvider, settings.providers),
+      success: true
+    };
+  }
+  if (subcommand === "use") {
+    return buildProviderSwitch(settings.providers, profileArg);
+  }
+  if (subcommand === "test") {
+    return await testProvider(settings.currentProvider, settings.providers, profileArg, deps);
+  }
+  if (subcommand === "add") {
+    return buildProviderSetup(profileArg, providerDefinitions);
+  }
+  return {
+    message: "Usage: provider [current|list|use <profile>|add <type>|test [profile]]",
+    success: false
+  };
+}
+function formatProviderList(currentProvider, providers) {
+  const entries = Object.entries(providers ?? {});
+  if (entries.length === 0) {
+    return "No provider profiles configured.";
+  }
+  return entries.map(([name, profile]) => {
+    const marker = name === currentProvider ? "*" : "-";
+    return `${marker} ${name}: ${profile.type ?? "unknown"} ${profile.model ?? "(no model)"}`;
+  }).join("\n");
+}
+function formatCurrentProvider(currentProvider, providers) {
+  if (!currentProvider) {
+    return "No current provider configured.";
+  }
+  const profile = providers?.[currentProvider];
+  if (!profile) {
+    return `Current provider "${currentProvider}" was not found in providers.`;
+  }
+  return [
+    `Current provider: ${currentProvider}`,
+    `Type: ${profile.type ?? "unknown"}`,
+    `Model: ${profile.model ?? "(no model)"}`,
+    ...profile.baseURL ? [`Base URL: ${profile.baseURL}`] : []
+  ].join("\n");
+}
+function buildProviderSwitch(providers, profileName) {
+  if (!profileName) {
+    return { message: "Usage: provider use <profile>", success: false };
+  }
+  if (!providers?.[profileName]) {
+    return { message: `Provider profile "${profileName}" was not found.`, success: false };
+  }
+  return {
+    message: `Provider change requested: ${profileName}`,
+    success: true,
+    data: { providerSwitch: { profile: profileName } }
+  };
+}
+function buildProviderSetup(type, providerDefinitions) {
+  if (!type || findProviderDefinition(providerDefinitions, type) === void 0) {
+    return {
+      message: `Usage: provider add <type>. Supported: ${formatSupportedProviderTypes(providerDefinitions)}`,
+      success: false
+    };
+  }
+  return {
+    message: `Provider setup requested: ${type}`,
+    success: true,
+    data: { providerSetup: { type } }
+  };
+}
+async function testProvider(currentProvider, providers, profileArg, deps) {
+  const profileName = profileArg ?? currentProvider;
+  if (!profileName) {
+    return { message: "No provider profile selected.", success: false };
+  }
+  const profile = providers?.[profileName];
+  if (!profile) {
+    return { message: `Provider profile "${profileName}" was not found.`, success: false };
+  }
+  try {
+    validateProviderProfile(profileName, profile, {
+      providerDefinitions: deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS
+    });
+  } catch (error) {
+    return { message: error instanceof Error ? error.message : String(error), success: false };
+  }
+  const providerDefinitions = deps.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  const definition = profile.type ? findProviderDefinition(providerDefinitions, profile.type) : void 0;
+  const probe = deps.probe ?? definition?.probeProfile ?? probeProviderProfile;
+  const result = await probe(profile);
+  return {
+    message: result.ok ? `Provider "${profileName}" test passed: ${result.message}` : `Provider "${profileName}" test failed: ${result.message}; manual configuration can continue.`,
+    success: true,
+    data: { providerTest: { profile: profileName } }
+  };
+}
+async function probeProviderProfile(profile) {
+  void profile;
+  return { ok: true, message: "Profile fields are valid; no endpoint probe configured." };
+}
+
+// src/ui/hooks/useSlashRouting.ts
+function useSlashRouting(cwd, interactiveSession, registry, manager, providerDefinitions) {
+  return useCallback(
+    async (input) => {
+      manager.onUserTurnAccepted();
+      if (!input.startsWith("/")) {
+        await interactiveSession.submit(input);
+        manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+        return;
+      }
+      const parts = input.slice(1).split(/\s+/);
+      const cmd = parts[0]?.toLowerCase() ?? "";
+      const args = parts.slice(1).join(" ");
+      if (cmd === "provider") {
+        await routeProviderCommand(cwd, args, interactiveSession, manager, providerDefinitions);
+        return;
+      }
+      const result = await interactiveSession.executeCommand(cmd, args);
+      if (result) {
+        applySystemCommandResult(result, interactiveSession, manager);
+        return;
+      }
+      if (await routeSkillCommand(input, cmd, registry, interactiveSession, manager)) {
+        return;
+      }
+      if (routeTuiCommand(cmd, interactiveSession)) {
+        return;
+      }
+      manager.addEntry(
+        messageToHistoryEntry(
+          createSystemMessage(`Unknown command "/${cmd}". Type /help for help.`)
+        )
+      );
+    },
+    [cwd, interactiveSession, registry, manager, providerDefinitions]
+  );
+}
+async function routeProviderCommand(cwd, args, interactiveSession, manager, providerDefinitions) {
+  const result = await handleProviderCommand(cwd, args, { providerDefinitions });
+  manager.addEntry(messageToHistoryEntry(createSystemMessage(result.message)));
+  const providerSwitch = result.data?.providerSwitch;
+  if (providerSwitch?.profile) {
+    getEffects(interactiveSession)._pendingProviderProfile = providerSwitch.profile;
+  }
+  const providerSetup = result.data?.providerSetup;
+  if (providerSetup?.type) {
+    getEffects(interactiveSession)._pendingProviderSetupType = providerSetup.type;
+  }
+}
+function applySystemCommandResult(result, interactiveSession, manager) {
+  manager.addEntry(messageToHistoryEntry(createSystemMessage(result.message)));
+  const data = result.data;
+  const effects = getEffects(interactiveSession);
+  if (typeof data?.modelId === "string") {
+    effects._pendingModelId = data.modelId;
+    return;
+  }
+  if (typeof data?.language === "string") {
+    effects._pendingLanguage = data.language;
+    return;
+  }
+  if (data?.resetRequested === true) {
+    effects._resetRequested = true;
+    return;
+  }
+  if (data?.triggerResumePicker === true) {
+    effects._triggerResumePicker = true;
+    return;
+  }
+  if (typeof data?.name === "string") {
+    effects._sessionName = data.name;
+    return;
+  }
+  const ctx = interactiveSession.getContextState();
+  manager.setContextState({
+    percentage: ctx.usedPercentage,
+    usedTokens: ctx.usedTokens,
+    maxTokens: ctx.maxTokens
+  });
+}
+async function routeSkillCommand(input, cmd, registry, interactiveSession, manager) {
+  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+  if (!skillCmd) {
+    return false;
+  }
+  manager.addEntry({
+    id: randomUUID2(),
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "skill-invocation",
+    data: {
+      skillName: cmd,
+      source: skillCmd.source,
+      message: `Invoking ${skillCmd.source}: ${cmd}`
+    }
+  });
+  const args = input.slice(1 + cmd.length).trimStart();
+  const qualifiedName = registry.resolveQualifiedName(cmd);
+  const hookInput = qualifiedName ? `/${qualifiedName}${input.slice(1 + cmd.length)}` : input;
+  await interactiveSession.executeSkillCommand(skillCmd, args, input, hookInput);
+  manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+  return true;
+}
+function routeTuiCommand(cmd, interactiveSession) {
+  if (cmd === "exit") {
+    getEffects(interactiveSession)._exitRequested = true;
+    return true;
+  }
+  if (cmd === "plugin") {
+    getEffects(interactiveSession)._triggerPluginTUI = true;
+    return true;
+  }
+  return false;
+}
+function getEffects(interactiveSession) {
+  return interactiveSession;
+}
+
+// src/ui/hooks/useInteractiveSession.ts
+function initializeSession(props, permissionHandler) {
+  const interactiveSession = new InteractiveSession({
+    cwd: props.cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    permissionHandler,
+    sessionStore: props.sessionStore,
+    resumeSessionId: props.resumeSessionId,
+    forkSession: props.forkSession,
+    sessionName: props.sessionName,
+    backgroundTaskRunners: props.backgroundTaskRunners,
+    subagentRunnerFactory: props.subagentRunnerFactory,
+    commandModules: props.commandModules
+  });
+  const registry = new CommandRegistry();
+  registry.addSource(new BuiltinCommandSource());
+  for (const module of props.commandModules ?? []) {
+    registry.addModule(module);
+  }
+  registry.addSource(new SkillCommandSource(props.cwd));
+  const pluginsDir = join5(homedir2(), ".robota", "plugins");
+  const loader = new BundlePluginLoader(pluginsDir);
+  try {
+    const plugins = loader.loadPluginsSync();
+    if (plugins.length > 0) {
+      registry.addSource(new PluginCommandSource(plugins));
+    }
+  } catch {
+  }
+  const manager = new TuiStateManager();
+  return { interactiveSession, registry, manager };
+}
+function useInteractiveSession(props) {
+  const [, forceRender] = useState(0);
+  const [permissionRequest, setPermissionRequest] = useState(null);
+  const [isShuttingDown, setIsShuttingDown] = useState(false);
+  const permissionQueueRef = useRef([]);
+  const processingRef = useRef(false);
+  const processNextPermission = useCallback2(() => {
+    if (processingRef.current) return;
+    const next = permissionQueueRef.current[0];
+    if (!next) {
+      setPermissionRequest(null);
+      return;
+    }
+    processingRef.current = true;
+    setPermissionRequest({
+      toolName: next.toolName,
+      toolArgs: next.toolArgs,
+      resolve: (result) => {
+        permissionQueueRef.current.shift();
+        processingRef.current = false;
+        setPermissionRequest(null);
+        next.resolve(result);
+        setTimeout(() => processNextPermission(), 0);
+      }
+    });
+  }, []);
+  const permissionHandler = useCallback2(
+    (toolName, toolArgs) => new Promise((resolve) => {
+      permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+      processNextPermission();
+    }),
+    [processNextPermission]
+  );
+  const stateRef = useRef(null);
+  if (stateRef.current === null) {
+    stateRef.current = initializeSession(props, permissionHandler);
+  }
+  const { interactiveSession, registry, manager } = stateRef.current;
+  manager.onChange = () => forceRender((n) => n + 1);
+  if (manager.history.length === 0) {
+    const restored = interactiveSession.getFullHistory();
+    if (restored.length > 0) {
+      manager.syncHistory(restored);
+    }
+  }
+  useEffect(() => {
+    interactiveSession.on("text_delta", manager.onTextDelta);
+    interactiveSession.on("tool_start", manager.onToolStart);
+    interactiveSession.on("tool_end", manager.onToolEnd);
+    interactiveSession.on("thinking", manager.onThinking);
+    interactiveSession.on("complete", manager.onComplete);
+    interactiveSession.on("interrupted", manager.onInterrupted);
+    interactiveSession.on("error", manager.onError);
+    interactiveSession.on("background_task_event", manager.onBackgroundTaskEvent);
+    const initCheck = setInterval(() => {
+      try {
+        const ctx = interactiveSession.getContextState();
+        manager.setContextState({
+          percentage: ctx.usedPercentage,
+          usedTokens: ctx.usedTokens,
+          maxTokens: ctx.maxTokens
+        });
+        const restored = interactiveSession.getFullHistory();
+        if (restored.length > 0) {
+          manager.syncHistory(restored);
+        }
+        clearInterval(initCheck);
+      } catch {
+      }
+    }, 200);
+    return () => {
+      clearInterval(initCheck);
+      interactiveSession.off("text_delta", manager.onTextDelta);
+      interactiveSession.off("tool_start", manager.onToolStart);
+      interactiveSession.off("tool_end", manager.onToolEnd);
+      interactiveSession.off("thinking", manager.onThinking);
+      interactiveSession.off("complete", manager.onComplete);
+      interactiveSession.off("interrupted", manager.onInterrupted);
+      interactiveSession.off("error", manager.onError);
+      interactiveSession.off("background_task_event", manager.onBackgroundTaskEvent);
+    };
+  }, [interactiveSession, manager]);
+  useEffect(() => {
+    manager.syncHistory(interactiveSession.getFullHistory());
+    if (!manager.isThinking) {
+      manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+    }
+  }, [manager.isThinking, interactiveSession, manager]);
+  const handleSubmit = useSlashRouting(
+    props.cwd,
+    interactiveSession,
+    registry,
+    manager,
+    props.providerDefinitions ?? []
+  );
+  const handleAbort = useCallback2(() => {
+    manager.setAborting(true);
+    interactiveSession.abort();
+  }, [interactiveSession, manager]);
+  const handleCancelQueue = useCallback2(() => {
+    interactiveSession.cancelQueue();
+    manager.setPendingPrompt(null);
+  }, [interactiveSession, manager]);
+  const handleShutdown = useCallback2(
+    async (reason = "prompt_input_exit") => {
+      if (isShuttingDown) return;
+      setIsShuttingDown(true);
+      manager.addEntry(messageToHistoryEntry2(createSystemMessage2("Shutting down...")));
+      await interactiveSession.shutdown({ reason, message: "CLI shutdown" });
+    },
+    [interactiveSession, manager, isShuttingDown]
+  );
+  return {
+    interactiveSession,
+    registry,
+    history: manager.history,
+    addEntry: (entry) => manager.addEntry(entry),
+    streamingText: manager.streamingText,
+    activeTools: manager.activeTools,
+    isThinking: manager.isThinking,
+    isAborting: manager.isAborting,
+    isShuttingDown,
+    pendingPrompt: manager.pendingPrompt,
+    backgroundTasks: manager.backgroundTasks,
+    permissionRequest,
+    contextState: manager.contextState,
+    handleSubmit,
+    handleAbort,
+    handleCancelQueue,
+    handleShutdown
+  };
+}
+
+// src/ui/hooks/usePluginCallbacks.ts
+import { useMemo } from "react";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+import {
+  PluginSettingsStore,
+  BundlePluginLoader as BundlePluginLoader2,
+  BundlePluginInstaller,
+  MarketplaceClient
+} from "@robota-sdk/agent-sdk";
+function usePluginCallbacks(cwd) {
+  return useMemo(() => {
+    const home = homedir3();
+    const pluginsDir = join6(home, ".robota", "plugins");
+    const userSettingsPath = join6(home, ".robota", "settings.json");
+    const settingsStore = new PluginSettingsStore(userSettingsPath);
+    const marketplace = new MarketplaceClient({ pluginsDir });
+    const installer = new BundlePluginInstaller({
+      pluginsDir,
+      settingsStore,
+      marketplaceClient: marketplace
+    });
+    const loader = new BundlePluginLoader2(pluginsDir);
+    return {
+      listInstalled: async () => {
+        const plugins = await loader.loadAll();
+        const enabledMap = settingsStore.getEnabledPlugins();
+        return plugins.map((p) => {
+          const parts = p.pluginDir.split("/");
+          const cacheIdx = parts.indexOf("cache");
+          const marketplaceName = cacheIdx >= 0 ? parts[cacheIdx + 1] : "";
+          const fullId = marketplaceName ? `${p.manifest.name}@${marketplaceName}` : p.manifest.name;
+          return {
+            name: fullId,
+            description: p.manifest.description,
+            enabled: enabledMap[fullId] !== false && enabledMap[p.manifest.name] !== false
+          };
+        });
+      },
+      listAvailablePlugins: async (marketplaceName) => {
+        let manifest;
+        try {
+          manifest = marketplace.fetchManifest(marketplaceName);
+        } catch {
+          return [];
+        }
+        const installed = installer.getInstalledPlugins();
+        const installedNames = new Set(Object.values(installed).map((r) => r.pluginName));
+        return manifest.plugins.map((p) => ({
+          name: p.name,
+          description: p.description,
+          installed: installedNames.has(p.name)
+        }));
+      },
+      install: async (pluginId, scope) => {
+        const [name, marketplaceName] = pluginId.split("@");
+        if (!name || !marketplaceName) {
+          throw new Error("Plugin ID must be in format: name@marketplace");
+        }
+        if (scope === "project") {
+          const projectPluginsDir = join6(cwd, ".robota", "plugins");
+          const projectInstaller = new BundlePluginInstaller({
+            pluginsDir: projectPluginsDir,
+            settingsStore,
+            marketplaceClient: marketplace
+          });
+          await projectInstaller.install(name, marketplaceName);
+        } else {
+          await installer.install(name, marketplaceName);
+        }
+      },
+      uninstall: async (pluginId) => {
+        await installer.uninstall(pluginId);
+      },
+      enable: async (pluginId) => {
+        await installer.enable(pluginId);
+      },
+      disable: async (pluginId) => {
+        await installer.disable(pluginId);
+      },
+      marketplaceAdd: async (source) => {
+        if (source.includes("/") && !source.includes(":")) {
+          return marketplace.addMarketplace({ type: "github", repo: source });
+        } else {
+          return marketplace.addMarketplace({ type: "git", url: source });
+        }
+      },
+      marketplaceRemove: async (name) => {
+        const installedFromMarketplace = installer.getPluginsByMarketplace(name);
+        for (const record of installedFromMarketplace) {
+          await installer.uninstall(`${record.pluginName}@${record.marketplace}`);
+        }
+        marketplace.removeMarketplace(name);
+      },
+      marketplaceUpdate: async (name) => {
+        marketplace.updateMarketplace(name);
+      },
+      marketplaceList: async () => {
+        return marketplace.listMarketplaces().map((m) => ({
+          name: m.name,
+          type: m.source.type
+        }));
+      },
+      reloadPlugins: async () => {
+      }
+    };
+  }, [cwd]);
+}
+
+// src/ui/hooks/useSideEffects.ts
+import { useState as useState2, useRef as useRef2, useCallback as useCallback3 } from "react";
+import { useApp } from "ink";
+import { createSystemMessage as createSystemMessage3, messageToHistoryEntry as messageToHistoryEntry3, getModelName } from "@robota-sdk/agent-core";
+var EXIT_DELAY_MS = 500;
+function useSideEffects({
+  cwd,
+  interactiveSession,
+  addEntry,
+  baseHandleSubmit,
+  setSessionName,
+  providerDefinitions
+}) {
+  const { exit } = useApp();
+  const [pendingModelId, setPendingModelId] = useState2(null);
+  const pendingModelChangeRef = useRef2(null);
+  const [pendingProviderProfile, setPendingProviderProfile] = useState2(null);
+  const pendingProviderProfileRef = useRef2(null);
+  const [pendingProviderSetupType, setPendingProviderSetupType] = useState2(null);
+  const [showPluginTUI, setShowPluginTUI] = useState2(false);
+  const [showSessionPicker, setShowSessionPicker] = useState2(false);
+  const requestShutdown = useCallback3(
+    (reason, message) => {
+      addEntry(messageToHistoryEntry3(createSystemMessage3("Shutting down...")));
+      setTimeout(() => {
+        void interactiveSession.shutdown({ reason, message }).finally(() => exit());
+      }, EXIT_DELAY_MS);
+    },
+    [interactiveSession, addEntry, exit]
+  );
+  const handleSubmit = useCallback3(
+    async (input) => {
+      await baseHandleSubmit(input);
+      const sideEffects = interactiveSession;
+      if (sideEffects._pendingModelId) {
+        const modelId = sideEffects._pendingModelId;
+        delete sideEffects._pendingModelId;
+        pendingModelChangeRef.current = modelId;
+        setPendingModelId(modelId);
+        return;
+      }
+      if (sideEffects._pendingLanguage) {
+        const lang = sideEffects._pendingLanguage;
+        delete sideEffects._pendingLanguage;
+        const settingsPath = getUserSettingsPath();
+        const settings = readSettings(settingsPath);
+        settings.language = lang;
+        writeSettings(settingsPath, settings);
+        addEntry(
+          messageToHistoryEntry3(createSystemMessage3(`Language set to "${lang}". Restarting...`))
+        );
+        requestShutdown("other", "Language change restart");
+        return;
+      }
+      if (sideEffects._pendingProviderProfile) {
+        const profile = sideEffects._pendingProviderProfile;
+        delete sideEffects._pendingProviderProfile;
+        pendingProviderProfileRef.current = profile;
+        setPendingProviderProfile(profile);
+        return;
+      }
+      if (sideEffects._pendingProviderSetupType) {
+        const type = sideEffects._pendingProviderSetupType;
+        delete sideEffects._pendingProviderSetupType;
+        setPendingProviderSetupType(type);
+        return;
+      }
+      if (sideEffects._resetRequested) {
+        delete sideEffects._resetRequested;
+        const settingsPath = getUserSettingsPath();
+        if (deleteSettings(settingsPath)) {
+          addEntry(
+            messageToHistoryEntry3(createSystemMessage3(`Deleted ${settingsPath}. Exiting...`))
+          );
+        } else {
+          addEntry(messageToHistoryEntry3(createSystemMessage3("No user settings found.")));
+        }
+        requestShutdown("other", "Reset settings restart");
+        return;
+      }
+      if (sideEffects._exitRequested) {
+        delete sideEffects._exitRequested;
+        requestShutdown("prompt_input_exit", "User requested exit");
+        return;
+      }
+      if (sideEffects._triggerPluginTUI) {
+        delete sideEffects._triggerPluginTUI;
+        setShowPluginTUI(true);
+        return;
+      }
+      if (sideEffects._triggerResumePicker) {
+        delete sideEffects._triggerResumePicker;
+        setShowSessionPicker(true);
+        return;
+      }
+      if (sideEffects._sessionName) {
+        const name = sideEffects._sessionName;
+        delete sideEffects._sessionName;
+        interactiveSession.setName(name);
+        setSessionName(name);
+        return;
+      }
+    },
+    [interactiveSession, baseHandleSubmit, addEntry, requestShutdown, setSessionName]
+  );
+  const handleModelConfirm = useCallback3(
+    (index) => {
+      const modelId = pendingModelChangeRef.current;
+      setPendingModelId(null);
+      pendingModelChangeRef.current = null;
+      if (index === 0 && modelId) {
+        try {
+          const settingsPath = getUserSettingsPath();
+          updateModelInSettings(settingsPath, modelId);
+          addEntry(
+            messageToHistoryEntry3(
+              createSystemMessage3(`Model changed to ${getModelName(modelId)}. Restarting...`)
+            )
+          );
+          requestShutdown("other", "Model change restart");
+        } catch (err) {
+          addEntry(
+            messageToHistoryEntry3(
+              createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            )
+          );
+        }
+      } else {
+        addEntry(messageToHistoryEntry3(createSystemMessage3("Model change cancelled.")));
+      }
+    },
+    [addEntry, requestShutdown]
+  );
+  const handleProviderConfirm = useCallback3(
+    (index) => {
+      const profile = pendingProviderProfileRef.current;
+      setPendingProviderProfile(null);
+      pendingProviderProfileRef.current = null;
+      if (index === 0 && profile) {
+        try {
+          const settingsPath = getUserSettingsPath();
+          applyProviderSwitch(settingsPath, profile, {
+            knownProviders: readMergedProviderSettings(cwd).providers
+          });
+          addEntry(
+            messageToHistoryEntry3(
+              createSystemMessage3(`Provider changed to ${profile}. Restarting...`)
+            )
+          );
+          requestShutdown("other", "Provider change restart");
+        } catch (err) {
+          addEntry(
+            messageToHistoryEntry3(
+              createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            )
+          );
+        }
+      } else {
+        addEntry(messageToHistoryEntry3(createSystemMessage3("Provider change cancelled.")));
+      }
+    },
+    [cwd, addEntry, requestShutdown]
+  );
+  const handleProviderSetupSubmit = useCallback3(
+    (input) => {
+      setPendingProviderSetupType(null);
+      try {
+        const settingsPath = getUserSettingsPath();
+        applyProviderConfiguration(settingsPath, input, { providerDefinitions });
+        addEntry(
+          messageToHistoryEntry3(
+            createSystemMessage3(`Provider ${input.profile} configured. Restarting...`)
+          )
+        );
+        requestShutdown("other", "Provider setup restart");
+      } catch (err) {
+        addEntry(
+          messageToHistoryEntry3(
+            createSystemMessage3(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+          )
+        );
+      }
+    },
+    [addEntry, requestShutdown, providerDefinitions]
+  );
+  const handleProviderSetupCancel = useCallback3(() => {
+    setPendingProviderSetupType(null);
+    addEntry(messageToHistoryEntry3(createSystemMessage3("Provider setup cancelled.")));
+  }, [addEntry]);
+  return {
+    handleSubmit,
+    pendingModelId,
+    pendingProviderProfile,
+    pendingProviderSetupType,
+    showPluginTUI,
+    showSessionPicker,
+    setPendingModelId,
+    setShowPluginTUI,
+    setShowSessionPicker,
+    handleModelConfirm,
+    handleProviderConfirm,
+    handleProviderSetupSubmit,
+    handleProviderSetupCancel
+  };
+}
+
+// src/ui/MessageList.tsx
+import React from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { isToolMessage, isAssistantMessage } from "@robota-sdk/agent-core";
+
+// src/ui/render-markdown.ts
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+marked.setOptions({
+  renderer: new TerminalRenderer()
+});
+function renderMarkdown(md) {
+  const result = marked.parse(md);
+  return typeof result === "string" ? result.trimEnd() : md;
+}
+
+// src/ui/DiffBlock.tsx
+import { Box, Text } from "ink";
+import { jsxs } from "react/jsx-runtime";
+var MAX_DIFF_LINES = 12;
+var TRUNCATED_SHOW = 10;
+function DiffBlock({ file, lines }) {
+  const truncated = lines.length > MAX_DIFF_LINES;
+  const visible = truncated ? lines.slice(0, TRUNCATED_SHOW) : lines;
+  const remaining = lines.length - TRUNCATED_SHOW;
+  const maxLineNum = Math.max(...visible.map((l) => l.lineNumber), 0);
+  const numWidth = String(maxLineNum).length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 4, children: [
+    file && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+      "\u2502 ",
+      file
+    ] }),
+    visible.map((line, i) => {
+      const lineNum = String(line.lineNumber).padStart(numWidth, " ");
+      if (line.type === "context") {
+        return /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+          "\u2502 ",
+          lineNum,
+          " ",
+          line.text
+        ] }, i);
+      }
+      const prefix = line.type === "remove" ? "-" : "+";
+      const bgColor = line.type === "remove" ? "#5c1a1a" : "#1a3d1a";
+      const fgColor = line.type === "remove" ? "#ff9999" : "#99ff99";
+      return /* @__PURE__ */ jsxs(Text, { color: fgColor, backgroundColor: bgColor, children: [
+        "\u2502 ",
+        lineNum,
+        " ",
+        prefix,
+        " ",
+        line.text
+      ] }, i);
+    }),
+    truncated && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+      "\u2502 ... and ",
+      remaining,
+      " more lines"
+    ] })
+  ] });
+}
+
+// src/ui/MessageList.tsx
+import { Fragment, jsx, jsxs as jsxs2 } from "react/jsx-runtime";
+function RoleLabel({ role }) {
+  switch (role) {
+    case "user":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "green", bold: true, children: [
+        "You:",
+        " "
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "cyan", bold: true, children: [
+        "Robota:",
+        " "
+      ] });
+    case "system":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
+        "System:",
+        " "
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] });
+  }
+}
+function ToolMessage({ message }) {
+  if (!isToolMessage(message)) {
+    return /* @__PURE__ */ jsx(Fragment, {});
+  }
+  const toolName = message.name;
+  const content = message.content;
+  let summaries = null;
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed) && parsed.length > 0 && typeof parsed[0].line === "string") {
+      summaries = parsed;
+    }
+  } catch {
+  }
+  if (summaries) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+          "Tool:",
+          " "
+        ] }),
+        toolName && /* @__PURE__ */ jsxs2(Text2, { color: "white", dimColor: true, children: [
+          "[",
+          toolName,
+          "]"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Text2, { children: " " }),
+      summaries.map((s, i) => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+          "  ",
+          "\u2713",
+          " ",
+          s.line
+        ] }),
+        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ jsx(DiffBlock, { file: s.diffFile, lines: s.diffLines })
+      ] }, i))
+    ] });
+  }
+  const lines = content.split("\n").filter((l) => l.trim());
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] }),
+      toolName && /* @__PURE__ */ jsxs2(Text2, { color: "white", dimColor: true, children: [
+        "[",
+        toolName,
+        "]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+      "  ",
+      "\u2713",
+      " ",
+      line
+    ] }, i))
+  ] });
+}
+var MessageItem = React.memo(function MessageItem2({
+  message
+}) {
+  if (isToolMessage(message)) {
+    return /* @__PURE__ */ jsx(ToolMessage, { message });
+  }
+  const content = message.content ?? "";
+  const isInterrupted = message.state === "interrupted";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsx(RoleLabel, { role: message.role }) }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    /* @__PURE__ */ jsx(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text2, { wrap: "wrap", children: isAssistantMessage(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+  ] });
+});
+function ToolSummaryEntry({ entry }) {
+  const data = entry.data;
+  const lines = data?.summary?.split("\n") ?? [];
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+      "Tool:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+      "  ",
+      line
+    ] }, i))
+  ] });
+}
+function EventEntry({ entry }) {
+  const eventData = entry.data;
+  const eventMessage = typeof eventData?.message === "string" ? eventData.message : typeof eventData?.content === "string" ? eventData.content : entry.type;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
+      "System:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    /* @__PURE__ */ jsx(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text2, { wrap: "wrap", children: eventMessage }) })
+  ] });
+}
+function EntryItem({ entry }) {
+  if (entry.category === "chat") {
+    const message = entry.data;
+    return /* @__PURE__ */ jsx(MessageItem, { message });
+  }
+  if (entry.type === "tool-summary") {
+    return /* @__PURE__ */ jsx(ToolSummaryEntry, { entry });
+  }
+  if (entry.type === "tool-start" || entry.type === "tool-end") {
+    return /* @__PURE__ */ jsx(Fragment, {});
+  }
+  return /* @__PURE__ */ jsx(EventEntry, { entry });
+}
+function MessageList({ history }) {
+  return /* @__PURE__ */ jsx(Box2, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ jsx(EntryItem, { entry }, entry.id)) });
+}
+
+// src/ui/StatusBar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { formatTokenCount } from "@robota-sdk/agent-core";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs3 } from "react/jsx-runtime";
+var CONTEXT_YELLOW_THRESHOLD = 70;
+var CONTEXT_RED_THRESHOLD = 90;
+function getContextColor(percentage) {
+  if (percentage >= CONTEXT_RED_THRESHOLD) return "red";
+  if (percentage >= CONTEXT_YELLOW_THRESHOLD) return "yellow";
+  return "green";
+}
+function StatusBar({
+  permissionMode,
+  modelName,
+  sessionId: _sessionId,
+  messageCount,
+  isThinking,
+  contextPercentage,
+  contextUsedTokens,
+  contextMaxTokens,
+  sessionName
+}) {
+  const contextColor = getContextColor(contextPercentage);
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingLeft: 1,
+      paddingRight: 1,
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          /* @__PURE__ */ jsx2(Text3, { color: "cyan", bold: true, children: "Mode:" }),
+          " ",
+          /* @__PURE__ */ jsx2(Text3, { children: permissionMode }),
+          sessionName && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+            "  |  ",
+            /* @__PURE__ */ jsx2(Text3, { color: "magenta", children: sessionName })
+          ] }),
+          "  |  ",
+          /* @__PURE__ */ jsx2(Text3, { dimColor: true, children: modelName }),
+          "  |  ",
+          /* @__PURE__ */ jsxs3(Text3, { color: contextColor, children: [
+            "Context: ",
+            Math.round(contextPercentage),
+            "% (",
+            formatTokenCount(contextUsedTokens),
+            "/",
+            formatTokenCount(contextMaxTokens),
+            ")"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          isThinking && /* @__PURE__ */ jsx2(Text3, { color: "yellow", children: "Thinking... " }),
+          /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+            "msgs: ",
+            messageCount
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/ui/InputArea.tsx
+import { useState as useState6, useCallback as useCallback4, useRef as useRef4 } from "react";
+import { Box as Box5, Text as Text7, useInput as useInput2, useStdout } from "ink";
+
+// src/ui/CjkTextInput.tsx
+import { useRef as useRef3, useState as useState3 } from "react";
+import { Text as Text4, useInput } from "ink";
+import chalk from "chalk";
+
+// src/ui/flows/cjk-text-input-flow.ts
+import stringWidth from "string-width";
+var PASTE_START = "[200~";
+var PASTE_END = "[201~";
+var LAST_ASCII_CONTROL_CODE = 31;
+var DELETE_CONTROL_CODE = 127;
+function createCjkTextInputFlowState(value) {
+  return { value, cursor: value.length, isPasting: false, pasteBuffer: "" };
+}
+function syncCjkTextInputFlowState(state, value, cursorHint) {
+  if (value === state.value) {
+    return state;
+  }
+  return {
+    ...state,
+    value,
+    cursor: cursorHint != null ? Math.min(cursorHint, value.length) : value.length
+  };
+}
+function applyCjkTextInput(state, input, key, options) {
+  const pasteResult = applyPasteBoundaryInput(state, input, options);
+  if (pasteResult !== void 0) return pasteResult;
+  const controlResult = applyControlInput(state, input, key, options);
+  if (controlResult !== void 0) return controlResult;
+  const cursorResult = applyCursorInput(state, key, options.availableWidth);
+  if (cursorResult !== void 0) return cursorResult;
+  return insertPrintableInput(state, input);
+}
+function applyPasteBoundaryInput(state, input, options) {
+  if (input === PASTE_START || input.startsWith(PASTE_START)) {
+    return startBracketedPaste(state, input);
+  }
+  if (state.isPasting) {
+    return continueBracketedPaste(state, input, options);
+  }
+  return void 0;
+}
+function applyControlInput(state, input, key, options) {
+  if (key.ctrl === true && input === "c" || key.tab === true) {
+    return { state, effect: { type: "none" } };
+  }
+  if (key.return === true) {
+    return { state, effect: { type: "submit", value: state.value } };
+  }
+  if (input.length > 1 && (input.includes("\n") || input.includes("\r")) && options.canPaste) {
+    return {
+      state,
+      effect: { type: "paste", text: input.replace(/\r\n?/g, "\n"), cursor: state.cursor }
+    };
+  }
+  return void 0;
+}
+function applyCursorInput(state, key, availableWidth) {
+  if (key.upArrow === true || key.downArrow === true) {
+    return moveCursorVertically(state, key.upArrow === true ? "up" : "down", availableWidth);
+  }
+  if (key.leftArrow === true) {
+    return moveCursorHorizontally(state, "left");
+  }
+  if (key.rightArrow === true) {
+    return moveCursorHorizontally(state, "right");
+  }
+  if (key.backspace === true || key.delete === true) {
+    return deleteBeforeCursor(state);
+  }
+  return void 0;
+}
+function filterPrintable(input) {
+  if (!input || input.length === 0) return "";
+  let output = "";
+  for (const char of input) {
+    const code = char.charCodeAt(0);
+    if (code > LAST_ASCII_CONTROL_CODE && code !== DELETE_CONTROL_CODE) {
+      output += char;
+    }
+  }
+  return output;
+}
+function insertAtCursor(value, cursor, input) {
+  const next = value.slice(0, cursor) + input + value.slice(cursor);
+  return { value: next, cursor: cursor + input.length };
+}
+function displayOffset(chars, charIndex, width) {
+  let offset = 0;
+  for (let i = 0; i < charIndex && i < chars.length; i++) {
+    const w = stringWidth(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return offset;
+}
+function charIndexAtDisplayOffset(chars, target, width) {
+  let offset = 0;
+  for (let i = 0; i < chars.length; i++) {
+    if (offset >= target) return i;
+    const w = stringWidth(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return chars.length;
+}
+function startBracketedPaste(state, input) {
+  return {
+    state: { ...state, isPasting: true, pasteBuffer: input.slice(PASTE_START.length) },
+    effect: { type: "none" }
+  };
+}
+function continueBracketedPaste(state, input, options) {
+  if (input !== PASTE_END && !input.includes(PASTE_END)) {
+    return {
+      state: { ...state, pasteBuffer: state.pasteBuffer + input },
+      effect: { type: "none" }
+    };
+  }
+  const beforeMarker = input.split(PASTE_END)[0] ?? "";
+  const text = (state.pasteBuffer + beforeMarker).replace(/\r\n?/g, "\n");
+  const nextState = { ...state, isPasting: false, pasteBuffer: "" };
+  if (text.length === 0) {
+    return { state: nextState, effect: { type: "none" } };
+  }
+  if (text.includes("\n") && options.canPaste) {
+    return { state: nextState, effect: { type: "paste", text, cursor: state.cursor } };
+  }
+  return insertPrintableInput(nextState, text);
+}
+function moveCursorVertically(state, direction, availableWidth) {
+  if (!availableWidth || availableWidth <= 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const chars = [...state.value];
+  const offset = displayOffset(chars, state.cursor, availableWidth);
+  const target = direction === "up" ? offset - availableWidth : offset + availableWidth;
+  if (target < 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const cursor = charIndexAtDisplayOffset(chars, target, availableWidth);
+  if (cursor === state.cursor) {
+    return { state, effect: { type: "none" } };
+  }
+  return { state: { ...state, cursor }, effect: { type: "render" } };
+}
+function moveCursorHorizontally(state, direction) {
+  if (direction === "left" && state.cursor > 0) {
+    return { state: { ...state, cursor: state.cursor - 1 }, effect: { type: "render" } };
+  }
+  if (direction === "right" && state.cursor < state.value.length) {
+    return { state: { ...state, cursor: state.cursor + 1 }, effect: { type: "render" } };
+  }
+  return { state, effect: { type: "none" } };
+}
+function deleteBeforeCursor(state) {
+  if (state.cursor === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const value = state.value.slice(0, state.cursor - 1) + state.value.slice(state.cursor);
+  return {
+    state: { ...state, value, cursor: state.cursor - 1 },
+    effect: { type: "change", value }
+  };
+}
+function insertPrintableInput(state, input) {
+  const printable = filterPrintable(input);
+  if (printable.length === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  const result = insertAtCursor(state.value, state.cursor, printable);
+  return {
+    state: { ...state, value: result.value, cursor: result.cursor },
+    effect: { type: "change", value: result.value }
+  };
+}
+
+// src/ui/CjkTextInput.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function CjkTextInput({
+  value,
+  onChange,
+  onSubmit,
+  onPaste,
+  placeholder = "",
+  focus = true,
+  showCursor = true,
+  availableWidth,
+  cursorHint = null
+}) {
+  const stateRef = useRef3(createCjkTextInputFlowState(value));
+  const [, forceRender] = useState3(0);
+  stateRef.current = syncCjkTextInputFlowState(stateRef.current, value, cursorHint);
+  useInput(
+    (input, key) => {
+      try {
+        const result = applyCjkTextInput(stateRef.current, input, key, {
+          availableWidth,
+          canPaste: onPaste !== void 0
+        });
+        stateRef.current = result.state;
+        applyCjkTextInputEffect(result.effect, onChange, onSubmit, onPaste, forceRender);
+      } catch {
+      }
+    },
+    { isActive: focus }
+  );
+  return /* @__PURE__ */ jsx3(Text4, { children: renderWithCursor(
+    stateRef.current.value,
+    stateRef.current.cursor,
+    placeholder,
+    showCursor && focus
+  ) });
+}
+function applyCjkTextInputEffect(effect, onChange, onSubmit, onPaste, forceRender) {
+  if (effect.type === "change") {
+    onChange(effect.value);
+  } else if (effect.type === "submit") {
+    onSubmit?.(effect.value);
+  } else if (effect.type === "paste") {
+    onPaste?.(effect.text, effect.cursor);
+  } else if (effect.type === "render") {
+    forceRender((n) => n + 1);
+  }
+}
+function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
+  if (!showCursor) {
+    return value.length > 0 ? value : placeholder ? chalk.gray(placeholder) : "";
+  }
+  if (value.length === 0) {
+    if (placeholder.length > 0) {
+      return chalk.inverse(placeholder[0]) + chalk.gray(placeholder.slice(1));
+    }
+    return chalk.inverse(" ");
+  }
+  const chars = [...value];
+  let rendered = "";
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i] ?? "";
+    rendered += i === cursorOffset ? chalk.inverse(char) : char;
+  }
+  if (cursorOffset >= chars.length) {
+    rendered += chalk.inverse(" ");
+  }
+  return rendered;
+}
+
+// src/ui/WaveText.tsx
+import { useState as useState4, useEffect as useEffect2 } from "react";
+import { Text as Text5 } from "ink";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
+var INTERVAL_MS = 400;
+var CHARS_PER_GROUP = 4;
+function WaveText({ text }) {
+  const [tick, setTick] = useState4(0);
+  useEffect2(() => {
+    const timer = setInterval(() => {
+      setTick((prev) => prev + 1);
+    }, INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, []);
+  const chars = [...text];
+  return /* @__PURE__ */ jsx4(Text5, { children: chars.map((char, i) => {
+    const group = Math.floor(i / CHARS_PER_GROUP);
+    const colorIndex = (tick + group) % WAVE_COLORS.length;
+    return /* @__PURE__ */ jsx4(Text5, { color: WAVE_COLORS[colorIndex], children: char }, i);
+  }) });
+}
+
+// src/ui/SlashAutocomplete.tsx
+import { Box as Box4, Text as Text6 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var MAX_VISIBLE = 8;
+function CommandRow(props) {
+  const { cmd, isSelected, showSlash } = props;
+  const indicator = isSelected ? "\u25B8 " : "  ";
+  const nameColor = isSelected ? "cyan" : void 0;
+  const dimmed = !isSelected;
+  return /* @__PURE__ */ jsx5(Box4, { children: /* @__PURE__ */ jsxs4(Text6, { color: nameColor, dimColor: dimmed, children: [
+    indicator,
+    showSlash ? `/${cmd.name}  ${cmd.description}` : cmd.description
+  ] }) });
+}
+function SlashAutocomplete({
+  commands,
+  selectedIndex,
+  visible,
+  isSubcommandMode
+}) {
+  if (!visible || commands.length === 0) return null;
+  const scrollOffset = computeScrollOffset(selectedIndex, commands.length);
+  const visibleCommands = commands.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
+  return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ jsx5(
+    CommandRow,
+    {
+      cmd,
+      isSelected: scrollOffset + i === selectedIndex,
+      showSlash: !isSubcommandMode
+    },
+    cmd.name
+  )) });
+}
+function computeScrollOffset(selectedIndex, total) {
+  if (total <= MAX_VISIBLE) return 0;
+  if (selectedIndex < MAX_VISIBLE) return 0;
+  const maxOffset = total - MAX_VISIBLE;
+  return Math.min(selectedIndex - MAX_VISIBLE + 1, maxOffset);
+}
+
+// src/utils/paste-labels.ts
+var PASTE_LABEL_RE = /\[Pasted text #(\d+)(?: \+\d+ lines)?\]/g;
+function expandPasteLabels(text, store) {
+  return text.replace(PASTE_LABEL_RE, (_, id) => store.get(Number(id)) ?? "");
+}
+
+// src/ui/hooks/useAutocomplete.ts
+import React4, { useState as useState5, useMemo as useMemo2 } from "react";
+function parseSlashInput(value) {
+  if (!value.startsWith("/")) return { isSlash: false, parentCommand: "", filter: "" };
+  const afterSlash = value.slice(1);
+  const spaceIndex = afterSlash.indexOf(" ");
+  if (spaceIndex === -1) return { isSlash: true, parentCommand: "", filter: afterSlash };
+  const parent = afterSlash.slice(0, spaceIndex);
+  const rest = afterSlash.slice(spaceIndex + 1);
+  return { isSlash: true, parentCommand: parent, filter: rest };
+}
+function useAutocomplete(value, registry) {
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const [dismissed, setDismissed] = useState5(false);
+  const prevValueRef = React4.useRef(value);
+  if (prevValueRef.current !== value) {
+    prevValueRef.current = value;
+    if (dismissed) setDismissed(false);
+  }
+  const parsed = parseSlashInput(value);
+  const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
+  const filteredCommands = useMemo2(() => {
+    if (!registry || !parsed.isSlash || dismissed) return [];
+    if (isSubcommandMode) {
+      const subs = registry.getSubcommands(parsed.parentCommand);
+      if (subs.length === 0) return [];
+      if (!parsed.filter) return subs;
+      const lower = parsed.filter.toLowerCase();
+      return subs.filter((c) => c.name.toLowerCase().startsWith(lower));
+    }
+    return registry.getCommands(parsed.filter);
+  }, [registry, parsed.isSlash, parsed.parentCommand, parsed.filter, dismissed, isSubcommandMode]);
+  const showPopup = parsed.isSlash && filteredCommands.length > 0 && !dismissed;
+  if (selectedIndex >= filteredCommands.length && filteredCommands.length > 0) {
+    setSelectedIndex(filteredCommands.length - 1);
+  }
+  return {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup: (val) => {
+      if (typeof val === "function") {
+        setDismissed((prev) => {
+          const nextVal = val(!prev);
+          return !nextVal;
+        });
+      } else {
+        setDismissed(!val);
+      }
+    }
+  };
+}
+
+// src/ui/flows/input-area-flow.ts
+function getAutocompletePopupAction(key) {
+  if (key.upArrow === true) return "previous";
+  if (key.downArrow === true) return "next";
+  if (key.escape === true) return "close";
+  if (key.tab === true) return "complete";
+  return void 0;
+}
+function getPendingPromptInputAction(key) {
+  if (key.backspace === true || key.delete === true) {
+    return "cancelQueue";
+  }
+  return void 0;
+}
+function moveAutocompleteSelection(selectedIndex, commandCount, direction) {
+  if (commandCount === 0) return 0;
+  if (direction === "previous") {
+    return selectedIndex > 0 ? selectedIndex - 1 : commandCount - 1;
+  }
+  return selectedIndex < commandCount - 1 ? selectedIndex + 1 : 0;
+}
+function resolveTabCompletion(value, command) {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: "insert", value: `/${parsed.parentCommand} ${command.name} ` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: "insert", value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: "insert", value: `/${command.name} ` };
+}
+function resolveEnterCommandSelection(value, command) {
+  const parsed = parseSlashInput(value);
+  if (parsed.parentCommand) {
+    return { type: "submit", value: `/${parsed.parentCommand} ${command.name}` };
+  }
+  if (command.subcommands && command.subcommands.length > 0) {
+    return { type: "insert", value: `/${command.name} `, selectedIndex: 0 };
+  }
+  return { type: "submit", value: `/${command.name}` };
+}
+function createPasteLabelChange(value, cursorPosition, pasteId, text) {
+  const lineCount = text.split("\n").length;
+  const label = `[Pasted text #${pasteId} +${lineCount} lines]`;
+  return {
+    value: value.slice(0, cursorPosition) + label + value.slice(cursorPosition),
+    cursorHint: cursorPosition + label.length,
+    label,
+    lineCount
+  };
+}
+function shouldSubmitInput(text) {
+  return text.trim().length > 0;
+}
+
+// src/ui/InputArea.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var BORDER_HORIZONTAL = 2;
+var PADDING_LEFT = 1;
+var PROMPT_WIDTH = 2;
+var INPUT_AREA_OVERHEAD = BORDER_HORIZONTAL + PADDING_LEFT + PROMPT_WIDTH;
+function InputArea({
+  onSubmit,
+  onCancelQueue,
+  isDisabled,
+  isAborting,
+  pendingPrompt,
+  registry,
+  sessionName
+}) {
+  const [value, setValue] = useState6("");
+  const [cursorHint, setCursorHint] = useState6(null);
+  const pasteStore = useRef4(/* @__PURE__ */ new Map());
+  const { stdout } = useStdout();
+  const terminalColumns = stdout?.columns ?? 80;
+  const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
+  const pasteIdRef = useRef4(0);
+  const {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup
+  } = useAutocomplete(value, registry);
+  const handlePaste = useCallback4((text, cursorPosition) => {
+    pasteIdRef.current += 1;
+    const id = pasteIdRef.current;
+    pasteStore.current.set(id, text);
+    setValue((prev) => {
+      const change = createPasteLabelChange(prev, cursorPosition, id, text);
+      setCursorHint(change.cursorHint);
+      return change.value;
+    });
+  }, []);
+  const tabCompleteCommand = useCallback4(
+    (cmd) => {
+      const result = resolveTabCompletion(value, cmd);
+      if (result.type === "insert") {
+        setValue(result.value);
+        if (result.selectedIndex !== void 0) {
+          setSelectedIndex(result.selectedIndex);
+        }
+      }
+    },
+    [value, setSelectedIndex]
+  );
+  const enterSelectCommand = useCallback4(
+    (cmd) => {
+      const result = resolveEnterCommandSelection(value, cmd);
+      if (result.type === "insert") {
+        setValue(result.value);
+        if (result.selectedIndex !== void 0) {
+          setSelectedIndex(result.selectedIndex);
+        }
+        return;
+      }
+      setValue("");
+      onSubmit(result.value);
+    },
+    [value, onSubmit, setSelectedIndex]
+  );
+  const handleSubmit = useCallback4(
+    (text) => {
+      if (!shouldSubmitInput(text)) return;
+      if (showPopup && filteredCommands[selectedIndex]) {
+        enterSelectCommand(filteredCommands[selectedIndex]);
+        return;
+      }
+      const expanded = expandPasteLabels(text.trim(), pasteStore.current);
+      setValue("");
+      pasteStore.current.clear();
+      pasteIdRef.current = 0;
+      onSubmit(expanded);
+    },
+    [showPopup, filteredCommands, selectedIndex, onSubmit, enterSelectCommand]
+  );
+  useInput2(
+    (_input, key) => {
+      if (!showPopup) return;
+      const action = getAutocompletePopupAction(key);
+      if (action === "previous" || action === "next") {
+        setSelectedIndex(
+          (prev) => moveAutocompleteSelection(prev, filteredCommands.length, action)
+        );
+      } else if (action === "close") {
+        setShowPopup(false);
+      } else if (action === "complete") {
+        const cmd = filteredCommands[selectedIndex];
+        if (cmd) tabCompleteCommand(cmd);
+      }
+    },
+    { isActive: showPopup && !isDisabled }
+  );
+  useInput2(
+    (_input, key) => {
+      if (getPendingPromptInputAction(key) === "cancelQueue" && pendingPrompt) {
+        onCancelQueue?.();
+      }
+    },
+    { isActive: !!pendingPrompt }
+  );
+  const borderColor = isAborting ? "yellow" : pendingPrompt ? "cyan" : isDisabled ? "gray" : "green";
+  const innerWidth = Math.max(1, terminalColumns - BORDER_HORIZONTAL);
+  const topBorder = (() => {
+    if (sessionName) {
+      const label = ` "${sessionName}" `;
+      const rightPad = 2;
+      const leftLen = Math.max(0, innerWidth - label.length - rightPad);
+      return { left: "\u250C" + "\u2500".repeat(leftLen), label, right: "\u2500".repeat(rightPad) + "\u2510" };
+    }
+    return { left: "\u250C" + "\u2500".repeat(innerWidth), label: "", right: "\u2510" };
+  })();
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ jsx6(
+      SlashAutocomplete,
+      {
+        commands: filteredCommands,
+        selectedIndex,
+        visible: showPopup,
+        isSubcommandMode
+      }
+    ),
+    /* @__PURE__ */ jsxs5(Text7, { color: borderColor, children: [
+      topBorder.left,
+      topBorder.label ? /* @__PURE__ */ jsx6(Text7, { backgroundColor: borderColor, color: "black", bold: true, children: topBorder.label }) : null,
+      topBorder.right
+    ] }),
+    /* @__PURE__ */ jsx6(Box5, { borderStyle: "single", borderTop: false, borderColor, paddingLeft: 1, children: isAborting ? /* @__PURE__ */ jsx6(Text7, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ jsxs5(Text7, { color: "cyan", children: [
+      " ",
+      "Queued: ",
+      pendingPrompt.length > 50 ? pendingPrompt.slice(0, 47) + "..." : pendingPrompt,
+      " ",
+      /* @__PURE__ */ jsx6(Text7, { dimColor: true, children: "(Backspace to cancel)" })
+    ] }) : isDisabled ? /* @__PURE__ */ jsx6(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx6(Text7, { color: "green", bold: true, children: "> " }),
+      /* @__PURE__ */ jsx6(
+        CjkTextInput,
+        {
+          value,
+          onChange: (v) => {
+            setValue(v);
+            setCursorHint(null);
+          },
+          onSubmit: handleSubmit,
+          onPaste: handlePaste,
+          placeholder: "Type a message or /help",
+          availableWidth,
+          cursorHint
+        }
+      )
+    ] }) })
+  ] });
+}
+
+// src/ui/ConfirmPrompt.tsx
+import { useState as useState7, useRef as useRef5, useCallback as useCallback5 } from "react";
+import { Box as Box6, Text as Text8, useInput as useInput3 } from "ink";
+
+// src/ui/flows/selection-flow.ts
+function createSelectionFlowState() {
+  return { selectedIndex: 0, scrollOffset: 0, resolved: false };
+}
+function getVerticalSelectionInputAction(key) {
+  if (key.escape === true) return "cancel";
+  if (key.upArrow === true) return "previous";
+  if (key.downArrow === true) return "next";
+  if (key.return === true) return "select";
+  return void 0;
+}
+function getDirectionalSelectionInputAction(key) {
+  if (key.escape === true) return "cancel";
+  if (key.leftArrow === true || key.upArrow === true) return "previous";
+  if (key.rightArrow === true || key.downArrow === true) return "next";
+  if (key.return === true) return "select";
+  return void 0;
+}
+function applySelectionInput(state, action, options) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action === "cancel") {
+    return { state: { ...state, resolved: true }, effect: { type: "cancel" } };
+  }
+  if (options.enabled === false || options.itemCount === 0) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action === "select") {
+    const index = clampIndex(state.selectedIndex, options.itemCount);
+    return {
+      state: { ...state, selectedIndex: index, resolved: true },
+      effect: { type: "select", index }
+    };
+  }
+  const selectedIndex = moveSelection(state.selectedIndex, action, options);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  return { state: { ...state, selectedIndex, scrollOffset }, effect: { type: "none" } };
+}
+function normalizeSelectionState(state, options) {
+  if (options.itemCount === 0) {
+    return { ...state, selectedIndex: 0, scrollOffset: 0 };
+  }
+  const selectedIndex = clampIndex(state.selectedIndex, options.itemCount);
+  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
+  if (selectedIndex === state.selectedIndex && scrollOffset === state.scrollOffset) {
+    return state;
+  }
+  return {
+    ...state,
+    selectedIndex,
+    scrollOffset
+  };
+}
+function moveSelection(selectedIndex, action, options) {
+  if (action === "previous") {
+    if (options.wrap === true && selectedIndex === 0) return options.itemCount - 1;
+    return Math.max(0, selectedIndex - 1);
+  }
+  if (options.wrap === true && selectedIndex === options.itemCount - 1) return 0;
+  return Math.min(options.itemCount - 1, selectedIndex + 1);
+}
+function resolveScrollOffset(selectedIndex, scrollOffset, options) {
+  const maxVisible = options.maxVisible ?? options.itemCount;
+  if (maxVisible <= 0) return 0;
+  if (selectedIndex < scrollOffset) return selectedIndex;
+  if (selectedIndex >= scrollOffset + maxVisible) return selectedIndex - maxVisible + 1;
+  return Math.max(0, scrollOffset);
+}
+function clampIndex(index, itemCount) {
+  return Math.min(Math.max(index, 0), itemCount - 1);
+}
+
+// src/ui/flows/confirm-prompt-flow.ts
+function getConfirmPromptInputAction(input, key, optionCount) {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== void 0) {
+    return action;
+  }
+  if (optionCount === 2 && input === "y") {
+    return { type: "shortcut", index: 0 };
+  }
+  if (optionCount === 2 && input === "n") {
+    return { type: "shortcut", index: 1 };
+  }
+  return void 0;
+}
+function applyConfirmPromptInput(state, action, optionCount) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (typeof action !== "string") {
+    return {
+      state: { ...state, selectedIndex: action.index, resolved: true },
+      effect: { type: "select", index: action.index }
+    };
+  }
+  return applySelectionInput(state, action, { itemCount: optionCount });
+}
+
+// src/ui/ConfirmPrompt.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function ConfirmPrompt({
+  message,
+  options = ["Yes", "No"],
+  onSelect
+}) {
+  const [state, setState] = useState7(() => createSelectionFlowState());
+  const stateRef = useRef5(state);
+  const applyAction = useCallback5(
+    (action) => {
+      const result = applyConfirmPromptInput(stateRef.current, action, options.length);
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "select") {
+        onSelect(result.effect.index);
+      }
+    },
+    [onSelect, options.length]
+  );
+  useInput3((input, key) => {
+    const action = getConfirmPromptInputAction(input, key, options.length);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Text8, { color: "yellow", children: message }),
+    /* @__PURE__ */ jsx7(Box6, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ jsx7(Box6, { marginRight: 2, children: /* @__PURE__ */ jsxs6(
+      Text8,
+      {
+        color: i === state.selectedIndex ? "cyan" : void 0,
+        bold: i === state.selectedIndex,
+        children: [
+          i === state.selectedIndex ? "> " : "  ",
+          opt
+        ]
+      }
+    ) }, opt)) }),
+    /* @__PURE__ */ jsx7(Text8, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
+  ] });
+}
+
+// src/ui/ProviderSetupPrompt.tsx
+import { useState as useState9 } from "react";
+
+// src/ui/TextPrompt.tsx
+import { useState as useState8, useRef as useRef6, useCallback as useCallback6 } from "react";
+import { Box as Box7, Text as Text9, useInput as useInput4 } from "ink";
+
+// src/ui/flows/text-prompt-flow.ts
+function createTextPromptFlowState() {
+  return { value: "", resolved: false };
+}
+function getTextPromptInputAction(input, key) {
+  if (key.escape === true) {
+    return { type: "cancel" };
+  }
+  if (key.return === true) {
+    return { type: "submit" };
+  }
+  if (key.backspace === true || key.delete === true) {
+    return { type: "delete" };
+  }
+  if (input && key.ctrl !== true && key.meta !== true) {
+    return { type: "insert", value: input };
+  }
+  return void 0;
+}
+function applyTextPromptInput(state, action, options) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (action.type === "cancel") {
+    return { state: { ...state, resolved: true }, effect: { type: "cancel" } };
+  }
+  if (action.type === "delete") {
+    return {
+      state: { ...state, value: state.value.slice(0, -1), error: void 0 },
+      effect: { type: "none" }
+    };
+  }
+  if (action.type === "insert") {
+    return {
+      state: { ...state, value: state.value + action.value, error: void 0 },
+      effect: { type: "none" }
+    };
+  }
+  return submitTextPromptValue(state, options);
+}
+function submitTextPromptValue(state, options) {
+  const trimmed = state.value.trim();
+  if (!trimmed && !options.allowEmpty) {
+    const emptyError = options.validate?.(trimmed);
+    return {
+      state: emptyError ? { ...state, error: emptyError } : state,
+      effect: { type: "none" }
+    };
+  }
+  const error = options.validate?.(trimmed);
+  if (error !== void 0) {
+    return { state: { ...state, error }, effect: { type: "none" } };
+  }
+  return { state: { ...state, resolved: true }, effect: { type: "submit", value: trimmed } };
+}
+
+// src/ui/TextPrompt.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function TextPrompt({
+  title,
+  placeholder,
+  onSubmit,
+  onCancel,
+  validate,
+  allowEmpty = false,
+  masked = false
+}) {
+  const [state, setState] = useState8(() => createTextPromptFlowState());
+  const stateRef = useRef6(state);
+  const applyAction = useCallback6(
+    (action) => {
+      const result = applyTextPromptInput(stateRef.current, action, { allowEmpty, validate });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onCancel();
+      } else if (result.effect.type === "submit") {
+        onSubmit(result.effect.value);
+      }
+    },
+    [allowEmpty, validate, onCancel, onSubmit]
+  );
+  useInput4((input, key) => {
+    const action = getTextPromptInputAction(input, key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text9, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx8(Text9, { color: "cyan", children: "> " }),
+      state.value ? /* @__PURE__ */ jsx8(Text9, { children: masked ? "*".repeat(state.value.length) : state.value }) : placeholder ? /* @__PURE__ */ jsx8(Text9, { dimColor: true, children: placeholder }) : null,
+      /* @__PURE__ */ jsx8(Text9, { color: "cyan", children: "\u2588" })
+    ] }),
+    state.error && /* @__PURE__ */ jsx8(Text9, { color: "red", children: state.error }),
+    /* @__PURE__ */ jsx8(Text9, { dimColor: true, children: " Enter Submit Esc Cancel" })
+  ] });
+}
+
+// src/ui/ProviderSetupPrompt.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function ProviderSetupPrompt({
+  type,
+  providerDefinitions,
+  onSubmit,
+  onCancel
+}) {
+  const [state, setState] = useState9(
+    () => createProviderSetupFlow(type, providerDefinitions)
+  );
+  const step = getProviderSetupStep(state);
+  const handleStepSubmit = (rawValue) => {
+    const result = submitProviderSetupValue(state, rawValue);
+    if (result.status === "next") {
+      setState(result.state);
+      return;
+    }
+    if (result.status === "complete") {
+      onSubmit(result.input);
+    }
+  };
+  return /* @__PURE__ */ jsx9(
+    TextPrompt,
+    {
+      title: step.title,
+      placeholder: step.defaultValue,
+      allowEmpty: step.defaultValue !== void 0,
+      masked: step.masked,
+      validate: (value) => validateProviderSetupValue(step, value),
+      onSubmit: handleStepSubmit,
+      onCancel
+    },
+    `${type}-${step.key}`
+  );
+}
+
+// src/ui/PermissionPrompt.tsx
+import React9 from "react";
+import { Box as Box8, Text as Text10, useInput as useInput5 } from "ink";
+
+// src/ui/flows/permission-prompt-flow.ts
+var PERMISSION_PROMPT_OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
+function getPermissionPromptInputAction(input, key) {
+  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
+  if (action !== void 0) {
+    return action;
+  }
+  if (input === "y" || input === "1") {
+    return { type: "shortcut", index: 0 };
+  }
+  if (input === "a" || input === "2") {
+    return { type: "shortcut", index: 1 };
+  }
+  if (input === "n" || input === "d" || input === "3") {
+    return { type: "shortcut", index: 2 };
+  }
+  return void 0;
+}
+function applyPermissionPromptInput(state, action) {
+  if (state.resolved) {
+    return { state, effect: { type: "none" } };
+  }
+  if (typeof action !== "string") {
+    return resolvePermissionIndex(state, action.index);
+  }
+  const result = applySelectionInput(state, action, {
+    itemCount: PERMISSION_PROMPT_OPTIONS.length
+  });
+  if (result.effect.type !== "select") {
+    return { state: result.state, effect: { type: "none" } };
+  }
+  return {
+    state: result.state,
+    effect: { type: "resolve", decision: getPermissionDecision(result.effect.index) }
+  };
+}
+function getPermissionDecision(index) {
+  if (index === 0) return true;
+  if (index === 1) return "allow-session";
+  return false;
+}
+function resolvePermissionIndex(state, index) {
+  return {
+    state: { ...state, selectedIndex: index, resolved: true },
+    effect: { type: "resolve", decision: getPermissionDecision(index) }
+  };
+}
+
+// src/ui/PermissionPrompt.tsx
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function formatArgs(args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "(no arguments)";
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+function PermissionPrompt({ request }) {
+  const [state, setState] = React9.useState(() => createSelectionFlowState());
+  const stateRef = React9.useRef(state);
+  const prevRequestRef = React9.useRef(request);
+  if (prevRequestRef.current !== request) {
+    prevRequestRef.current = request;
+    const nextState = createSelectionFlowState();
+    stateRef.current = nextState;
+    setState(nextState);
+  }
+  const applyAction = React9.useCallback(
+    (action) => {
+      const result = applyPermissionPromptInput(stateRef.current, action);
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "resolve") {
+        request.resolve(result.effect.decision);
+      }
+    },
+    [request]
+  );
+  useInput5((input, key) => {
+    const action = getPermissionPromptInputAction(input, key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx10(Text10, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ jsxs8(Text10, { children: [
+      "Tool:",
+      " ",
+      /* @__PURE__ */ jsx10(Text10, { color: "cyan", bold: true, children: request.toolName })
+    ] }),
+    /* @__PURE__ */ jsxs8(Text10, { dimColor: true, children: [
+      " ",
+      formatArgs(request.toolArgs)
+    ] }),
+    /* @__PURE__ */ jsx10(Box8, { marginTop: 1, children: PERMISSION_PROMPT_OPTIONS.map((opt, i) => /* @__PURE__ */ jsx10(Box8, { marginRight: 2, children: /* @__PURE__ */ jsxs8(
+      Text10,
+      {
+        color: i === state.selectedIndex ? "cyan" : void 0,
+        bold: i === state.selectedIndex,
+        children: [
+          i === state.selectedIndex ? "> " : "  ",
+          opt
+        ]
+      }
+    ) }, opt)) }),
+    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: " left/right to select, Enter to confirm" })
+  ] });
+}
+
+// src/ui/StreamingIndicator.tsx
+import { Box as Box9, Text as Text11 } from "ink";
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function getToolStyle(t) {
+  if (t.isRunning) return { color: "yellow", icon: "\u27F3", strikethrough: false };
+  if (t.result === "error") return { color: "red", icon: "\u2717", strikethrough: true };
+  if (t.result === "denied") return { color: "yellowBright", icon: "\u2298", strikethrough: true };
+  return { color: "green", icon: "\u2713", strikethrough: false };
+}
+function StreamingIndicator({ text, activeTools }) {
+  const hasTools = activeTools.length > 0;
+  const hasText = text.length > 0;
+  if (!hasTools && !hasText) {
+    return /* @__PURE__ */ jsx11(Fragment3, {});
+  }
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    hasTools && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: "white", bold: true, children: "Tools:" }),
+      /* @__PURE__ */ jsx11(Text11, { children: " " }),
+      activeTools.map((t, i) => {
+        const { color, icon, strikethrough } = getToolStyle(t);
+        return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs9(Text11, { color, strikethrough, children: [
+            "  ",
+            icon,
+            " ",
+            t.toolName,
+            "(",
+            t.firstArg,
+            ")"
+          ] }),
+          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ jsx11(DiffBlock, { file: t.diffFile, lines: t.diffLines })
+        ] }, `${t.toolName}-${i}`);
+      })
+    ] }),
+    hasText && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ jsx11(Text11, { children: " " }),
+      /* @__PURE__ */ jsx11(Box9, { marginLeft: 2, children: /* @__PURE__ */ jsx11(Text11, { wrap: "wrap", children: renderMarkdown(text) }) })
+    ] })
+  ] });
+}
+
+// src/ui/PluginTUI.tsx
+import { useState as useState12, useCallback as useCallback8 } from "react";
+
+// src/ui/MenuSelect.tsx
+import { useState as useState10, useCallback as useCallback7, useRef as useRef7 } from "react";
+import { Box as Box10, Text as Text12, useInput as useInput6 } from "ink";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function MenuSelect({
+  title,
+  items,
+  onSelect,
+  onBack,
+  loading,
+  error
+}) {
+  const [state, setState] = useState10(() => createSelectionFlowState());
+  const stateRef = useRef7(state);
+  const isEnabled = !loading && !error;
+  const applyAction = useCallback7(
+    (action) => {
+      const result = applySelectionInput(stateRef.current, action, {
+        itemCount: items.length,
+        enabled: isEnabled
+      });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onBack();
+      } else if (result.effect.type === "select") {
+        const item = items[result.effect.index];
+        if (item !== void 0) {
+          onSelect(item.value);
+        }
+      }
+    },
+    [isEnabled, items, onBack, onSelect]
+  );
+  useInput6((input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  const normalizedState = normalizeSelectionState(state, { itemCount: items.length });
+  if (normalizedState !== state) {
+    stateRef.current = normalizedState;
+  }
+  const selected = normalizedState.selectedIndex;
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Text12, { color: "yellow", bold: true, children: title }),
+    loading && /* @__PURE__ */ jsx12(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Loading..." }) }),
+    error && /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Text12, { color: "red", children: error }),
+      /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Press Esc to go back" })
+    ] }),
+    !loading && !error && /* @__PURE__ */ jsx12(Box10, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ jsxs10(Box10, { children: [
+      /* @__PURE__ */ jsxs10(Text12, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+        i === selected ? "> " : "  ",
+        item.label
+      ] }),
+      item.hint && /* @__PURE__ */ jsxs10(Text12, { dimColor: true, children: [
+        " ",
+        item.hint
+      ] })
+    ] }, item.value)) }),
+    /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
+  ] });
+}
+
+// src/ui/plugin-tui-handlers.ts
+function handleMainSelect(value, nav) {
+  if (value === "marketplace") {
+    nav.push({ screen: "marketplace-list" });
+  } else if (value === "installed") {
+    nav.push({ screen: "installed-list" });
+  }
+}
+function handleMarketplaceListSelect(value, nav) {
+  if (value === "__add__") {
+    nav.push({ screen: "marketplace-add" });
+  } else {
+    nav.push({ screen: "marketplace-action", context: { marketplace: value } });
+  }
+}
+function handleMarketplaceActionSelect(value, marketplace, callbacks, nav) {
+  if (value === "browse") {
+    nav.push({ screen: "marketplace-browse", context: { marketplace } });
+  } else if (value === "update") {
+    callbacks.marketplaceUpdate(marketplace).then(() => {
+      nav.notify(`Updated marketplace "${marketplace}".`);
+      nav.pop();
+    }).catch((err) => {
+      nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  } else if (value === "remove") {
+    nav.setConfirm({
+      message: `Remove marketplace "${marketplace}" and all its plugins?`,
+      onConfirm: () => {
+        nav.setConfirm(void 0);
+        callbacks.marketplaceRemove(marketplace).then(() => {
+          nav.notify(`Removed marketplace "${marketplace}".`);
+          nav.popN(2);
+        }).catch((err) => {
+          nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      },
+      onCancel: () => nav.setConfirm(void 0)
+    });
+  }
+}
+function handleMarketplaceBrowseSelect(value, marketplace, items, nav) {
+  const fullId = `${value}@${marketplace}`;
+  const item = items.find((i) => i.value === value);
+  if (item?.hint === "installed") {
+    nav.push({ screen: "installed-action", context: { pluginId: fullId } });
+  } else {
+    nav.push({ screen: "marketplace-install-scope", context: { marketplace, pluginId: fullId } });
+  }
+}
+function handleInstallScopeSelect(value, pluginId, callbacks, nav) {
+  const scope = value;
+  callbacks.install(pluginId, scope).then(() => {
+    nav.notify(`Installed plugin "${pluginId}" (${scope} scope).`);
+    nav.popN(2);
+  }).catch((err) => {
+    nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
+function handleInstalledListSelect(value, callbacks, nav) {
+  nav.setConfirm({
+    message: `Uninstall plugin "${value}"?`,
+    onConfirm: () => {
+      nav.setConfirm(void 0);
+      callbacks.uninstall(value).then(() => {
+        nav.notify(`Uninstalled plugin "${value}".`);
+        nav.refresh();
+      }).catch((err) => {
+        nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    },
+    onCancel: () => nav.setConfirm(void 0)
+  });
+}
+function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
+  if (value === "uninstall") {
+    nav.setConfirm({
+      message: `Uninstall plugin "${pluginId}"?`,
+      onConfirm: () => {
+        nav.setConfirm(void 0);
+        callbacks.uninstall(pluginId).then(() => {
+          nav.notify(`Uninstalled plugin "${pluginId}".`);
+          nav.popN(2);
+        }).catch((err) => {
+          nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      },
+      onCancel: () => nav.setConfirm(void 0)
+    });
+  }
+}
+
+// src/ui/hooks/usePluginScreenData.ts
+import { useState as useState11, useEffect as useEffect3 } from "react";
+function usePluginScreenData(screen, marketplace, callbacks, refreshCounter, stackLength) {
+  const [items, setItems] = useState11([]);
+  const [loading, setLoading] = useState11(false);
+  const [error, setError] = useState11();
+  useEffect3(() => {
+    setItems([]);
+    setError(void 0);
+    if (screen === "marketplace-list") {
+      setLoading(true);
+      callbacks.marketplaceList().then((sources) => {
+        const baseItems = [{ label: "Add Marketplace", value: "__add__" }];
+        const sourceItems = sources.map((s) => ({
+          label: s.name,
+          value: s.name,
+          hint: s.type
+        }));
+        setItems([...baseItems, ...sourceItems]);
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    } else if (screen === "marketplace-browse") {
+      const mp = marketplace ?? "";
+      setLoading(true);
+      callbacks.listAvailablePlugins(mp).then((plugins) => {
+        setItems(
+          plugins.map((p) => ({
+            label: p.name,
+            value: p.name,
+            hint: p.installed ? "installed" : p.description
+          }))
+        );
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    } else if (screen === "installed-list") {
+      setLoading(true);
+      callbacks.listInstalled().then((plugins) => {
+        setItems(
+          plugins.map((p) => ({
+            label: p.name,
+            value: p.name,
+            hint: p.description
+          }))
+        );
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    }
+  }, [stackLength, screen, marketplace, callbacks, refreshCounter]);
+  return { items, loading, error };
+}
+
+// src/ui/PluginTUI.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function PluginTUI({ callbacks, onClose, addMessage }) {
+  const [stack, setStack] = useState12([{ screen: "main" }]);
+  const [confirm, setConfirm] = useState12();
+  const [refreshCounter, setRefreshCounter] = useState12(0);
+  const current = stack[stack.length - 1] ?? { screen: "main" };
+  const push = useCallback8((state) => {
+    setStack((prev) => [...prev, state]);
+  }, []);
+  const pop = useCallback8(() => {
+    setStack((prev) => {
+      if (prev.length <= 1) {
+        onClose();
+        return prev;
+      }
+      return prev.slice(0, -1);
+    });
+  }, [onClose]);
+  const popN = useCallback8(
+    (n) => {
+      setStack((prev) => {
+        const next = prev.slice(0, Math.max(1, prev.length - n));
+        if (next.length === 0) {
+          onClose();
+          return prev;
+        }
+        return next;
+      });
+    },
+    [onClose]
+  );
+  const notify = useCallback8(
+    (content) => {
+      addMessage?.({ role: "system", content });
+    },
+    [addMessage]
+  );
+  const refresh = useCallback8(() => {
+    setRefreshCounter((c) => c + 1);
+  }, []);
+  const setConfirmNav = useCallback8(
+    (state) => setConfirm(state),
+    [setConfirm]
+  );
+  const pushNav = useCallback8(
+    (state) => push({ screen: state.screen, context: state.context }),
+    [push]
+  );
+  const nav = { push: pushNav, pop, popN, notify, setConfirm: setConfirmNav, refresh };
+  const { items, loading, error } = usePluginScreenData(
+    current.screen,
+    current.context?.marketplace,
+    callbacks,
+    refreshCounter,
+    stack.length
+  );
+  const handleSelect = useCallback8(
+    (value) => {
+      const screen2 = current.screen;
+      const ctx = current.context;
+      if (screen2 === "main") handleMainSelect(value, nav);
+      else if (screen2 === "marketplace-list") handleMarketplaceListSelect(value, nav);
+      else if (screen2 === "marketplace-action")
+        handleMarketplaceActionSelect(value, ctx?.marketplace ?? "", callbacks, nav);
+      else if (screen2 === "marketplace-browse")
+        handleMarketplaceBrowseSelect(value, ctx?.marketplace ?? "", items, nav);
+      else if (screen2 === "marketplace-install-scope")
+        handleInstallScopeSelect(value, ctx?.pluginId ?? "", callbacks, nav);
+      else if (screen2 === "installed-list") handleInstalledListSelect(value, callbacks, nav);
+      else if (screen2 === "installed-action")
+        handleInstalledActionSelect(value, ctx?.pluginId ?? "", callbacks, nav);
+    },
+    [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
+  );
+  const handleTextSubmit = useCallback8(
+    (value) => {
+      if (current.screen === "marketplace-add") {
+        callbacks.marketplaceAdd(value).then((name) => {
+          notify(`Added marketplace "${name}" from ${value}.`);
+          pop();
+        }).catch((err) => {
+          notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+          pop();
+        });
+      }
+    },
+    [current.screen, callbacks, notify, pop]
+  );
+  if (confirm) {
+    return /* @__PURE__ */ jsx13(
+      ConfirmPrompt,
+      {
+        message: confirm.message,
+        onSelect: (index) => {
+          if (index === 0) confirm.onConfirm();
+          else confirm.onCancel();
+        }
+      }
+    );
+  }
+  const screen = current.screen;
+  if (screen === "marketplace-add") {
+    return /* @__PURE__ */ jsx13(
+      TextPrompt,
+      {
+        title: "Add Marketplace Source",
+        placeholder: "owner/repo or git URL",
+        onSubmit: handleTextSubmit,
+        onCancel: pop,
+        validate: (v) => !v.includes("/") ? "Must be owner/repo or a git URL" : void 0
+      }
+    );
+  }
+  if (screen === "marketplace-action") {
+    return /* @__PURE__ */ jsx13(
+      MenuSelect,
+      {
+        title: `Marketplace: ${current.context?.marketplace ?? ""}`,
+        items: [
+          { label: "Browse plugins", value: "browse" },
+          { label: "Update", value: "update" },
+          { label: "Remove", value: "remove" }
+        ],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  if (screen === "marketplace-install-scope") {
+    return /* @__PURE__ */ jsx13(
+      MenuSelect,
+      {
+        title: `Install scope for "${current.context?.pluginId ?? ""}"`,
+        items: [
+          { label: "User scope", value: "user" },
+          { label: "Project scope", value: "project" }
+        ],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  if (screen === "installed-action") {
+    return /* @__PURE__ */ jsx13(
+      MenuSelect,
+      {
+        title: `Plugin: ${current.context?.pluginId ?? ""}`,
+        items: [{ label: "Uninstall", value: "uninstall" }],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  const titleMap = {
+    main: "Plugin Management",
+    "marketplace-list": "Marketplace",
+    "marketplace-browse": `Browse: ${current.context?.marketplace ?? ""}`,
+    "installed-list": "Installed Plugins"
+  };
+  const staticItemsMap = {
+    main: [
+      { label: "Marketplace", value: "marketplace" },
+      { label: "Installed Plugins", value: "installed" }
+    ]
+  };
+  return /* @__PURE__ */ jsx13(
+    MenuSelect,
+    {
+      title: titleMap[screen] ?? "Plugin Management",
+      items: staticItemsMap[screen] ?? items,
+      onSelect: handleSelect,
+      onBack: pop,
+      loading,
+      error
+    },
+    `${screen}-${stack.length}-${refreshCounter}`
+  );
+}
+
+// src/ui/SessionPicker.tsx
+import { Box as Box12, Text as Text14 } from "ink";
+
+// src/ui/ListPicker.tsx
+import { useState as useState13, useRef as useRef8, useCallback as useCallback9 } from "react";
+import { Box as Box11, Text as Text13, useInput as useInput7 } from "ink";
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+var DEFAULT_MAX_VISIBLE = 3;
+function ListPicker({
+  items,
+  renderItem,
+  onSelect,
+  onCancel,
+  maxVisible = DEFAULT_MAX_VISIBLE
+}) {
+  const [state, setState] = useState13(() => createSelectionFlowState());
+  const stateRef = useRef8(state);
+  const applyAction = useCallback9(
+    (action) => {
+      const result = applySelectionInput(stateRef.current, action, {
+        itemCount: items.length,
+        maxVisible
+      });
+      stateRef.current = result.state;
+      setState(result.state);
+      if (result.effect.type === "cancel") {
+        onCancel();
+      } else if (result.effect.type === "select") {
+        const item = items[result.effect.index];
+        if (item !== void 0) {
+          onSelect(item);
+        }
+      }
+    },
+    [items, maxVisible, onCancel, onSelect]
+  );
+  useInput7((_input, key) => {
+    const action = getVerticalSelectionInputAction(key);
+    if (action !== void 0) {
+      applyAction(action);
+    }
+  });
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx14(Box11, {});
+  }
+  const normalizedState = normalizeSelectionState(state, { itemCount: items.length, maxVisible });
+  if (normalizedState !== state) {
+    stateRef.current = normalizedState;
+  }
+  const { selectedIndex, scrollOffset } = normalizedState;
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxVisible);
+  const hasMore = scrollOffset + maxVisible < items.length;
+  const hasLess = scrollOffset > 0;
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+    hasLess && /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+      " \u2191 ",
+      scrollOffset,
+      " more above"
+    ] }),
+    visibleItems.map((item, index) => /* @__PURE__ */ jsx14(Box11, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
+    hasMore && /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+      " \u2193 ",
+      items.length - scrollOffset - maxVisible,
+      " more below"
+    ] })
+  ] });
+}
+
+// src/ui/SessionPicker.tsx
+import { Fragment as Fragment4, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+var SESSION_ID_DISPLAY_LENGTH = 8;
+function SessionPicker({
+  sessionStore,
+  cwd,
+  onSelect,
+  onCancel
+}) {
+  const sessions = (sessionStore?.list() ?? []).filter((s) => s.cwd === cwd);
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx15(Text14, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
+    /* @__PURE__ */ jsx15(
+      ListPicker,
+      {
+        items: sessions,
+        renderItem: (session, isSelected) => {
+          const lastMsg = session.messages.slice().reverse().find((m) => {
+            const msg = m;
+            return msg.role === "assistant" && msg.content;
+          });
+          const rawPreview = lastMsg?.content?.replace(/[\n\r]+/g, " ").trim() ?? "";
+          const preview = rawPreview ? rawPreview.slice(0, 60) + (rawPreview.length > 60 ? "..." : "") : "";
+          return /* @__PURE__ */ jsxs12(Text14, { children: [
+            isSelected ? "> " : "  ",
+            /* @__PURE__ */ jsx15(Text14, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
+            "  ",
+            /* @__PURE__ */ jsx15(Text14, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
+              month: "short",
+              day: "numeric",
+              hour: "2-digit",
+              minute: "2-digit"
+            }) }),
+            "  ",
+            /* @__PURE__ */ jsxs12(Text14, { dimColor: true, children: [
+              "msgs: ",
+              session.messages.length
+            ] }),
+            preview ? /* @__PURE__ */ jsxs12(Fragment4, { children: [
+              "\n    ",
+              /* @__PURE__ */ jsx15(Text14, { color: "gray", children: preview })
+            ] }) : null
+          ] });
+        },
+        onSelect: (session) => onSelect(session.id),
+        onCancel
+      }
+    )
+  ] });
+}
+
+// src/ui/BackgroundTaskPanel.tsx
+import { Box as Box13, Text as Text15 } from "ink";
+import { jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
+var MS_PER_SECOND = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+function getStatusColor(status) {
+  if (status === "completed") return "green";
+  if (status === "failed") return "red";
+  if (status === "cancelled") return "yellow";
+  return "cyan";
+}
+function getStatusMarker(status) {
+  if (status === "queued" || status === "running") return "\u25A1";
+  return "\u25A0";
+}
+function getTaskPreview(task) {
+  return task.errorPreview ?? task.resultPreview ?? task.currentAction ?? task.preview;
+}
+function formatAge(iso) {
+  if (!iso) return void 0;
+  const timestamp = Date.parse(iso);
+  if (Number.isNaN(timestamp)) return void 0;
+  const seconds = Math.max(0, Math.floor((Date.now() - timestamp) / MS_PER_SECOND));
+  if (seconds < SECONDS_PER_MINUTE) return `${seconds}s`;
+  const minutes = Math.floor(seconds / SECONDS_PER_MINUTE);
+  if (minutes < MINUTES_PER_HOUR) return `${minutes}m`;
+  return `${Math.floor(minutes / MINUTES_PER_HOUR)}h`;
+}
+function BackgroundTaskPanel({ tasks }) {
+  if (tasks.length === 0) return null;
+  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx16(Text15, { color: "cyan", bold: true, children: "Background" }),
+    tasks.map((task) => /* @__PURE__ */ jsxs13(Text15, { children: [
+      "- ",
+      /* @__PURE__ */ jsx16(Text15, { color: getStatusColor(task.status), children: getStatusMarker(task.status) }),
+      ` ${task.kind}:${task.label} ${task.id}`,
+      task.status === "running" && formatAge(task.lastActivityAt) ? /* @__PURE__ */ jsx16(Text15, { dimColor: true, children: ` idle ${formatAge(task.lastActivityAt)}` }) : null,
+      task.timeoutReason ? /* @__PURE__ */ jsx16(Text15, { dimColor: true, children: ` (${task.timeoutReason})` }) : null,
+      getTaskPreview(task) ? /* @__PURE__ */ jsx16(Text15, { dimColor: true, children: ` - ${getTaskPreview(task)}` }) : null
+    ] }, task.id))
+  ] });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
+function App(props) {
+  const [activeSessionId, setActiveSessionId] = useState14(props.resumeSessionId);
+  return /* @__PURE__ */ jsx17(
+    AppInner,
+    {
+      ...props,
+      resumeSessionId: activeSessionId,
+      onSessionSwitch: (sessionId) => setActiveSessionId(sessionId)
+    },
+    activeSessionId ?? "__new__"
+  );
+}
+function AppInner(props) {
+  const cwd = props.cwd;
+  const providerDefinitions = props.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  const {
+    interactiveSession,
+    registry,
+    history,
+    addEntry,
+    streamingText,
+    activeTools,
+    isThinking,
+    isAborting,
+    isShuttingDown,
+    pendingPrompt,
+    backgroundTasks,
+    permissionRequest,
+    contextState,
+    handleSubmit: baseHandleSubmit,
+    handleAbort,
+    handleCancelQueue,
+    handleShutdown
+  } = useInteractiveSession({
+    cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    sessionStore: props.sessionStore,
+    resumeSessionId: props.resumeSessionId,
+    forkSession: props.forkSession,
+    sessionName: props.sessionName,
+    backgroundTaskRunners: props.backgroundTaskRunners,
+    subagentRunnerFactory: props.subagentRunnerFactory,
+    commandModules: props.commandModules,
+    providerDefinitions
+  });
+  const pluginCallbacks = usePluginCallbacks(cwd);
+  const { exit } = useApp2();
+  const [sessionName, setSessionName] = useState14(props.sessionName);
+  const {
+    handleSubmit,
+    pendingModelId,
+    pendingProviderProfile,
+    pendingProviderSetupType,
+    showPluginTUI,
+    showSessionPicker,
+    setShowPluginTUI,
+    setShowSessionPicker,
+    handleModelConfirm,
+    handleProviderConfirm,
+    handleProviderSetupSubmit,
+    handleProviderSetupCancel
+  } = useSideEffects({
+    cwd,
+    interactiveSession,
+    addEntry,
+    baseHandleSubmit,
+    setSessionName,
+    providerDefinitions
+  });
+  useEffect4(() => {
+    const name = interactiveSession?.getName?.();
+    if (name && !sessionName) setSessionName(name);
+  }, [interactiveSession, sessionName]);
+  useEffect4(() => {
+    const title = sessionName ? `Robota \u2014 ${sessionName}` : "Robota";
+    process.stdout.write(`\x1B]0;${title}\x07`);
+  }, [sessionName]);
+  useInput8((_input, key) => {
+    if (!key.escape || !isThinking) return;
+    if (permissionRequest || showPluginTUI || showSessionPicker) return;
+    handleAbort();
+  });
+  useInput8((input, key) => {
+    if (!key.ctrl || input !== "c" || isShuttingDown) return;
+    void handleShutdown("prompt_input_exit").finally(() => exit());
+  });
+  useEffect4(() => {
+    const onSigterm = () => {
+      if (isShuttingDown) return;
+      void handleShutdown("other").finally(() => exit());
+    };
+    process.once("SIGINT", onSigterm);
+    process.once("SIGTERM", onSigterm);
+    return () => {
+      process.off("SIGINT", onSigterm);
+      process.off("SIGTERM", onSigterm);
+    };
+  }, [handleShutdown, exit, isShuttingDown]);
+  let permissionMode = props.permissionMode ?? "default";
+  let sessionId = "";
+  try {
+    const session = interactiveSession.getSession();
+    permissionMode = session.getPermissionMode();
+    sessionId = session.getSessionId();
+  } catch {
+  }
+  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx17(Text16, { color: "cyan", bold: true, children: `
+  ____   ___  ____   ___ _____  _
+ |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
+ | |_) | | | |  _ \\| | | || | / _ \\
+ |  _ <| |_| | |_) | |_| || |/ ___ \\
+ |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
+` }),
+      /* @__PURE__ */ jsxs14(Text16, { dimColor: true, children: [
+        " v",
+        props.version ?? "0.0.0"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsx17(MessageList, { history }),
+      isShuttingDown && /* @__PURE__ */ jsx17(Box14, { marginBottom: 1, children: /* @__PURE__ */ jsx17(Text16, { color: "yellow", children: "Shutting down..." }) }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ jsx17(Box14, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx17(StreamingIndicator, { text: streamingText, activeTools }) }),
+      /* @__PURE__ */ jsx17(BackgroundTaskPanel, { tasks: backgroundTasks })
+    ] }),
+    permissionRequest && /* @__PURE__ */ jsx17(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ jsx17(
+      ConfirmPrompt,
+      {
+        message: `Change model to ${getModelName2(pendingModelId)}? This will restart the session.`,
+        onSelect: handleModelConfirm
+      }
+    ),
+    pendingProviderProfile && /* @__PURE__ */ jsx17(
+      ConfirmPrompt,
+      {
+        message: `Change provider to ${pendingProviderProfile}? This will restart the session.`,
+        onSelect: handleProviderConfirm
+      }
+    ),
+    pendingProviderSetupType && /* @__PURE__ */ jsx17(
+      ProviderSetupPrompt,
+      {
+        type: pendingProviderSetupType,
+        providerDefinitions,
+        onSubmit: handleProviderSetupSubmit,
+        onCancel: handleProviderSetupCancel
+      }
+    ),
+    showPluginTUI && /* @__PURE__ */ jsx17(
+      PluginTUI,
+      {
+        callbacks: pluginCallbacks,
+        onClose: () => setShowPluginTUI(false),
+        addMessage: (msg) => addEntry(messageToHistoryEntry4(createSystemMessage4(msg.content)))
+      }
+    ),
+    showSessionPicker && /* @__PURE__ */ jsx17(
+      SessionPicker,
+      {
+        sessionStore: props.sessionStore,
+        cwd: props.cwd,
+        onSelect: (id) => {
+          setShowSessionPicker(false);
+          props.onSessionSwitch(id);
+        },
+        onCancel: () => {
+          setShowSessionPicker(false);
+          addEntry(messageToHistoryEntry4(createSystemMessage4("Session resume cancelled.")));
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx17(
+      StatusBar,
+      {
+        permissionMode,
+        modelName: props.modelId ? getModelName2(props.modelId) : "",
+        sessionId,
+        messageCount: history.length,
+        isThinking,
+        contextPercentage: contextState.percentage,
+        contextUsedTokens: contextState.usedTokens,
+        contextMaxTokens: contextState.maxTokens,
+        sessionName
+      }
+    ),
+    /* @__PURE__ */ jsx17(
+      InputArea,
+      {
+        onSubmit: handleSubmit,
+        onCancelQueue: handleCancelQueue,
+        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || isShuttingDown || !!pendingProviderSetupType || isThinking && !!pendingPrompt,
+        isAborting,
+        pendingPrompt,
+        registry,
+        sessionName
+      }
+    ),
+    /* @__PURE__ */ jsx17(Text16, { children: " " })
+  ] });
+}
+
+// src/ui/render.tsx
+import { jsx as jsx18 } from "react/jsx-runtime";
+function renderApp(options) {
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`
+[UNHANDLED REJECTION] ${reason}
+`);
+    if (reason instanceof Error) {
+      process.stderr.write(`${reason.stack}
+`);
+    }
+  });
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write("\x1B[?2004h");
+  }
+  const instance = render(/* @__PURE__ */ jsx18(App, { ...options }), {
+    exitOnCtrlC: false
+  });
+  instance.waitUntilExit().then(() => {
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1B[?2004l");
+    }
+    process.exit(0);
+  }).catch((err) => {
+    if (err) {
+      process.stderr.write(`
+[EXIT ERROR] ${err}
+`);
+    }
+    process.exit(1);
+  });
+}
+
+// src/cli.ts
+function readVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const dir = dirname3(thisFile);
+    const candidates = [join7(dir, "..", "..", "package.json"), join7(dir, "..", "package.json")];
+    for (const pkgPath of candidates) {
+      try {
+        const raw = readFileSync4(pkgPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (pkg.version !== void 0 && pkg.name !== void 0) {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function promptInput(label, masked = false) {
+  return new Promise((resolve) => {
+    process.stdout.write(label);
+    let input = "";
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (data) => {
+      for (const ch of data) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.removeListener("data", onData);
+          stdin.setRawMode(wasRaw ?? false);
+          stdin.pause();
+          process.stdout.write("\n");
+          resolve(input.trim());
+          return;
+        } else if (ch === "\x7F" || ch === "\b") {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else if (ch === "") {
+          process.stdout.write("\n");
+          process.exit(0);
+        } else if (ch.charCodeAt(0) >= 32) {
+          input += ch;
+          process.stdout.write(masked ? "*" : ch);
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function resetConfig() {
+  const userPath = getUserSettingsPath();
+  if (deleteSettings(userPath)) {
+    process.stdout.write(`Deleted ${userPath}
+`);
+  } else {
+    process.stdout.write("No user settings found.\n");
+  }
+}
+async function startCli(options = {}) {
+  const args = parseCliArgs();
+  if (args.version) {
+    process.stdout.write(`robota ${readVersion()}
+`);
+    return;
+  }
+  if (args.reset) {
+    resetConfig();
+    return;
+  }
+  const cwd = process.cwd();
+  const providerDefinitions = options.providerDefinitions ?? DEFAULT_PROVIDER_DEFINITIONS;
+  if (args.configure) {
+    await runInteractiveProviderSetup(cwd, args, promptInput, providerDefinitions);
+    return;
+  }
+  if (handleProviderConfigurationArgs(cwd, args, providerDefinitions)) {
+    return;
+  }
+  try {
+    await ensureConfig(cwd, args, promptInput, providerDefinitions);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+  const providerOptions = args.provider ? { providerOverride: args.provider, providerDefinitions } : { providerDefinitions };
+  const providerSettings = readProviderSettings(cwd, providerOptions);
+  const modelId = args.model ?? providerSettings.model;
+  const provider = createProviderFromSettings(cwd, args.model, providerOptions);
+  const backgroundTaskRunners = [createManagedShellProcessRunner()];
+  const paths = projectPaths(cwd);
+  const subagentRunnerFactory = createChildProcessSubagentRunnerFactory({
+    providerConfig: { ...providerSettings, model: modelId },
+    logsDir: paths.logs
+  });
+  const sessionStore = new SessionStore(paths.sessions);
+  let resumeSessionId;
+  if (args.continueMode) {
+    const sessions = sessionStore.list().filter((s) => s.cwd === cwd);
+    if (sessions.length > 0) {
+      resumeSessionId = sessions[0].id;
+    }
+  } else if (args.resumeId !== void 0) {
+    if (args.resumeId === "") {
+      resumeSessionId = "__picker__";
+    } else {
+      const sessions = sessionStore.list();
+      const match = sessions.find((s) => s.id === args.resumeId || s.name === args.resumeId);
+      if (match) {
+        resumeSessionId = match.id;
+      } else {
+        process.stderr.write(`Session not found: ${args.resumeId}
+`);
+        process.exit(1);
+      }
+    }
+  }
+  if (args.printMode) {
+    let prompt = args.positional.join(" ").trim();
+    if (!prompt && !process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      prompt = Buffer.concat(chunks).toString("utf-8").trim();
+    }
+    if (!prompt) {
+      process.stderr.write("Print mode (-p) requires a prompt argument.\n");
+      process.exit(1);
+    }
+    const appendParts = [];
+    if (args.appendSystemPrompt) appendParts.push(args.appendSystemPrompt);
+    if (args.jsonSchema)
+      appendParts.push(
+        `Respond with valid JSON only, matching this JSON schema:
+${args.jsonSchema}`
+      );
+    const appendSystemPrompt = appendParts.length > 0 ? appendParts.join("\n\n") : void 0;
+    const session = new InteractiveSession2({
+      cwd,
+      provider,
+      permissionMode: args.permissionMode ?? "bypassPermissions",
+      maxTurns: args.maxTurns,
+      sessionStore: args.noSessionPersistence ? void 0 : sessionStore,
+      sessionName: args.sessionName,
+      bare: args.bare || void 0,
+      allowedTools: args.allowedTools ? args.allowedTools.split(",").map((t) => t.trim()).filter((t) => t.length > 0) : void 0,
+      appendSystemPrompt,
+      backgroundTaskRunners,
+      subagentRunnerFactory,
+      commandModules: options.commandModules
+    });
+    const transport = createHeadlessTransport({
+      outputFormat: args.outputFormat ?? "text",
+      prompt
+    });
+    session.attachTransport(transport);
+    await transport.start();
+    await session.shutdown({ reason: "prompt_input_exit", message: "Headless transport complete" });
+    process.exit(transport.getExitCode());
+  }
+  renderApp({
+    cwd,
+    provider,
+    modelId,
+    language: args.language,
+    permissionMode: args.permissionMode,
+    maxTurns: args.maxTurns,
+    version: readVersion(),
+    sessionStore,
+    resumeSessionId,
+    forkSession: args.forkSession,
+    sessionName: args.sessionName,
+    backgroundTaskRunners,
+    subagentRunnerFactory,
+    commandModules: options.commandModules,
+    providerDefinitions
+  });
+}
+
+export {
+  createManagedShellProcessRunner,
+  createGitWorktreeIsolationAdapter,
+  GitWorktreeIsolationAdapter,
+  createChildProcessSubagentRunnerFactory,
+  ChildProcessSubagentRunner,
+  startCli
+};