@microboxlabs/miot-chat 0.1.0

package/dist/cli.js

@@ -0,0 +1,3321 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/commands/ask.ts
+import { randomUUID } from "crypto";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+
+// src/miotrc.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function readMiotrcProfile(opts) {
+  const env = opts?.env ?? process.env;
+  const home = (env.HOME ?? homedir()) || ".";
+  try {
+    const parsed = JSON.parse(
+      readFileSync(join(home, ".miotrc.json"), "utf-8")
+    );
+    const name = opts?.profile ?? parsed.defaultProfile;
+    const profile = name ? parsed.profiles?.[name] : void 0;
+    if (!profile?.baseUrl || !profile.token) return null;
+    return {
+      baseUrl: profile.baseUrl,
+      token: profile.token,
+      ...typeof profile.organizationId === "string" && {
+        organizationId: profile.organizationId
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/config.ts
+var VALID_MODES = /* @__PURE__ */ new Set(["auto", "canned", "meta", "agentic"]);
+var DEFAULT_CONFIG = {
+  defaultProfile: "local",
+  profiles: {
+    local: {
+      baseUrl: "http://localhost:8000",
+      token: null,
+      tenantId: "demo-tenant",
+      userId: "demo-user"
+    }
+  }
+};
+function getConfigDir(env) {
+  const home = (env?.HOME ?? homedir2()) || ".";
+  return join2(home, ".miot-chat");
+}
+function readConfig(opts) {
+  const dir = opts?.configDir ?? getConfigDir();
+  const path = join2(dir, "config.json");
+  if (!existsSync(path)) return cloneDefault();
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return normalize(parsed);
+  } catch {
+    return cloneDefault();
+  }
+}
+function writeConfig(cfg, opts) {
+  const dir = opts?.configDir ?? getConfigDir();
+  const path = join2(dir, "config.json");
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, JSON.stringify(cfg, null, 2), { mode: 384 });
+}
+function upsertProfile(name, profile, opts) {
+  const dir = opts?.configDir ?? getConfigDir();
+  const path = join2(dir, "config.json");
+  const existed = existsSync(path);
+  const cfg = readConfig({ configDir: dir });
+  if (!existed) {
+    cfg.profiles = {};
+  }
+  cfg.profiles[name] = profile;
+  if (opts?.makeDefault || !existed || !cfg.profiles[cfg.defaultProfile]) {
+    cfg.defaultProfile = name;
+  }
+  writeConfig(cfg, { configDir: dir });
+}
+function resolveConfig(opts = {}) {
+  const env = opts.env ?? process.env;
+  const flags = opts.flags ?? {};
+  const cfg = readConfig({ configDir: opts.configDir ?? getConfigDir(env) });
+  const profileName = flags.profile ?? env.MIOT_CHAT_PROFILE ?? cfg.defaultProfile ?? "local";
+  const profile = cfg.profiles[profileName] ?? cfg.profiles[cfg.defaultProfile] ?? DEFAULT_CONFIG.profiles["local"];
+  const tokenFlag = flags.token ?? env.MIOT_CHAT_TOKEN;
+  const platform = tokenFlag === void 0 && (profile.token ?? null) === null ? readMiotrcProfile({ env }) : null;
+  const baseUrl = flags.baseUrl ?? env.MIOT_CHAT_BASE_URL ?? (platform ? platform.baseUrl : profile.baseUrl);
+  const token = tokenFlag ?? profile.token ?? platform?.token ?? null;
+  const tenantId = flags.tenant ?? env.MIOT_CHAT_TENANT_ID ?? profile.tenantId;
+  const userId = flags.user ?? env.MIOT_CHAT_USER_ID ?? profile.userId;
+  const modeRaw = flags.mode ?? env.MIOT_CHAT_MODE ?? profile.mode ?? "auto";
+  const mode = VALID_MODES.has(modeRaw) ? modeRaw : "auto";
+  const debug = Boolean(
+    flags.debug ?? (env.MIOT_CHAT_DEBUG ? env.MIOT_CHAT_DEBUG !== "0" : false)
+  );
+  const orgSlug = nonEmpty(flags.org) ?? nonEmpty(env.MIOT_CHAT_ORG) ?? nonEmpty(profile.orgSlug) ?? nonEmpty(platform?.organizationId) ?? null;
+  const harnessBaseUrl = orgSlug ? `${trimTrailingSlashes(baseUrl)}/api/v1/orgs/${encodeURIComponent(orgSlug)}/harness` : baseUrl;
+  return {
+    baseUrl,
+    token,
+    tenantId,
+    userId,
+    mode,
+    profileName,
+    theme: cfg.theme ?? null,
+    debug,
+    orgSlug,
+    harnessBaseUrl
+  };
+}
+function nonEmpty(v) {
+  return v === void 0 || v === "" ? void 0 : v;
+}
+function cloneDefault() {
+  return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+}
+function trimTrailingSlashes(s) {
+  let end = s.length;
+  while (end > 0 && s.charCodeAt(end - 1) === 47) end--;
+  return end === s.length ? s : s.slice(0, end);
+}
+function normalize(parsed) {
+  const profiles = {};
+  const sourceProfiles = parsed.profiles ?? {};
+  for (const [name, p] of Object.entries(sourceProfiles)) {
+    profiles[name] = {
+      baseUrl: p.baseUrl ?? "http://localhost:8000",
+      token: p.token ?? null,
+      tenantId: p.tenantId ?? "demo-tenant",
+      userId: p.userId ?? "demo-user",
+      mode: VALID_MODES.has(p.mode) ? p.mode : void 0,
+      ...typeof p.orgSlug === "string" && p.orgSlug !== "" ? { orgSlug: p.orgSlug } : void 0
+    };
+  }
+  if (Object.keys(profiles).length === 0) {
+    profiles.local = { ...DEFAULT_CONFIG.profiles.local };
+  }
+  return {
+    defaultProfile: parsed.defaultProfile && profiles[parsed.defaultProfile] ? parsed.defaultProfile : Object.keys(profiles)[0],
+    profiles,
+    theme: normalizeTheme(parsed.theme)
+  };
+}
+function normalizeTheme(theme) {
+  if (theme === void 0 || theme === null) return void 0;
+  if (typeof theme === "string") return theme;
+  if (typeof theme === "object") {
+    const out = {};
+    if (typeof theme.name === "string") out.name = theme.name;
+    if (theme.tokens && typeof theme.tokens === "object") {
+      const tokens = {};
+      for (const [k, v] of Object.entries(
+        theme.tokens
+      )) {
+        if (typeof v === "string") tokens[k] = v;
+      }
+      if (Object.keys(tokens).length > 0) out.tokens = tokens;
+    }
+    return out.name || out.tokens ? out : void 0;
+  }
+  return void 0;
+}
+
+// src/commands/ask.ts
+import {
+  MiotHarnessApiError,
+  createMiotHarnessClient
+} from "@microboxlabs/miot-harness-client";
+
+// src/output.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+var CLEAR_LINE = `\r${ESC}K`;
+function useColor(opts = {}) {
+  if (opts.noColor === true) return false;
+  if (opts.isTTY === false) return false;
+  return true;
+}
+function dim(s, opts = {}) {
+  return useColor(opts) ? `${ESC}2m${s}${RESET}` : s;
+}
+function bold(s, opts = {}) {
+  return useColor(opts) ? `${ESC}1m${s}${RESET}` : s;
+}
+function red(s, opts = {}) {
+  return useColor(opts) ? `${ESC}31m${s}${RESET}` : s;
+}
+function yellow(s, opts = {}) {
+  return useColor(opts) ? `${ESC}33m${s}${RESET}` : s;
+}
+
+// src/repl/renderer.ts
+import {
+  TERMINAL_EVENT_TYPES
+} from "@microboxlabs/miot-harness-client";
+function statusPrefix(state) {
+  if (!state.hasStatusLine) return "";
+  return useColor(state.color) ? CLEAR_LINE : "\n";
+}
+function statusSuffix(color) {
+  return useColor(color) ? "" : "\n";
+}
+function initialState(color = {}) {
+  return {
+    pendingAnswer: null,
+    hasStatusLine: false,
+    pendingThinking: "",
+    hasThinkingBlock: false,
+    color
+  };
+}
+function renderEvent(state, event) {
+  switch (event.type) {
+    case "answer.completed":
+      return {
+        state: {
+          ...state,
+          pendingAnswer: extractAnswerText(event) ?? state.pendingAnswer
+        },
+        output: ""
+      };
+    case "run.completed":
+    case "run.failed":
+      return clearStatus(state);
+    case "thinking.delta": {
+      const delta = typeof event.data.delta === "string" ? event.data.delta : "";
+      if (!delta) return { state, output: "" };
+      const prefix = state.hasStatusLine ? statusPrefix(state) : "";
+      return {
+        state: {
+          ...state,
+          hasStatusLine: false,
+          pendingThinking: state.pendingThinking + delta,
+          hasThinkingBlock: true
+        },
+        output: `${prefix}${dim(delta, state.color)}`
+      };
+    }
+    case "thinking.completed": {
+      const output = state.hasThinkingBlock ? "\n" : "";
+      return {
+        state: { ...state, hasThinkingBlock: false },
+        output
+      };
+    }
+    default: {
+      if (TERMINAL_EVENT_TYPES.has(event.type)) {
+        return { state, output: "" };
+      }
+      const summary = statusFor(event);
+      if (summary === null) return { state, output: "" };
+      const prefix = statusPrefix(state);
+      const line = colorize(event.type, summary, state.color);
+      const suffix = statusSuffix(state.color);
+      return {
+        state: {
+          ...state,
+          hasStatusLine: useColor(state.color) ? true : false
+        },
+        output: `${prefix}${line}${suffix}`
+      };
+    }
+  }
+}
+function clearStatus(state) {
+  if (!state.hasStatusLine) return { state, output: "" };
+  return { state: { ...state, hasStatusLine: false }, output: statusPrefix(state) };
+}
+function renderAuthoritativeAnswer(state, answer) {
+  const prefix = statusPrefix(state);
+  const text = answer ?? state.pendingAnswer ?? "(no answer recorded)";
+  const lead = state.hasThinkingBlock ? "\n" : "";
+  return {
+    state: {
+      ...state,
+      hasStatusLine: false,
+      hasThinkingBlock: false,
+      pendingAnswer: text
+    },
+    output: `${lead}${prefix}${bold(text, state.color)}
+`
+  };
+}
+function renderRunFailure(state, message) {
+  const prefix = statusPrefix(state);
+  return {
+    state: { ...state, hasStatusLine: false },
+    output: `${prefix}${red(`error: ${message || "run failed"}`, state.color)}
+`
+  };
+}
+function extractAnswerText(event) {
+  const data = event.data;
+  if (typeof data?.text === "string" && data.text.length > 0) return data.text;
+  if (typeof data?.answer === "string" && data.answer.length > 0) {
+    return data.answer;
+  }
+  return event.message.length > 0 ? event.message : null;
+}
+function colorize(type, text, color) {
+  if (type === "freshness.warning") return yellow(text, color);
+  if (type === "tool.failed") return red(text, color);
+  if (type === "agent.started" || type === "agent.completed") {
+    return bold(text, color);
+  }
+  return dim(text, color);
+}
+function statusFor(event) {
+  switch (event.type) {
+    case "run.started":
+      return "starting\u2026";
+    case "route.selected": {
+      const route = typeof event.data.route === "string" ? event.data.route : event.message;
+      return route ? `route: ${route}` : null;
+    }
+    case "agent.turn": {
+      const agent = typeof event.data.agent === "string" ? event.data.agent : event.message;
+      return agent ? `agent: ${agent}` : null;
+    }
+    case "agent.started": {
+      const agent = typeof event.data.agent === "string" ? event.data.agent : event.message;
+      return agent ? `\u25B6 ${agent}` : null;
+    }
+    case "agent.completed": {
+      const agent = typeof event.data.agent === "string" ? event.data.agent : event.message;
+      const ms = typeof event.data.duration_ms === "number" ? event.data.duration_ms : null;
+      if (!agent) return null;
+      return ms !== null ? `\u2713 ${agent} (${ms}ms)` : `\u2713 ${agent}`;
+    }
+    case "plan.created":
+      return event.message || "plan ready";
+    case "tool.started": {
+      const name = toolName(event);
+      if (!name) return null;
+      const keys = Array.isArray(event.data.input_keys) ? event.data.input_keys.join(",") : "";
+      return keys ? `tool: ${name}(${keys})` : `tool: ${name}`;
+    }
+    case "tool.completed": {
+      const name = toolName(event);
+      const shape = event.data.result_shape;
+      const tail = shape && typeof shape.type === "string" ? ` \u2192 ${shape.type}[${shape.length ?? 0}]` : "";
+      if (!name) return "tool ok";
+      return `tool ok: ${name}${tail}`;
+    }
+    case "tool.failed": {
+      const name = toolName(event);
+      return name ? `tool failed: ${name}` : "tool failed";
+    }
+    case "freshness.warning":
+      return event.message || "stale data";
+    case "approval.requested":
+      return event.message || "approval needed";
+    case "artifact.created": {
+      const kind = typeof event.data.kind === "string" ? event.data.kind : "artifact";
+      return `artifact: ${kind}`;
+    }
+    case "usage.recorded": {
+      const agent = typeof event.data.agent === "string" ? event.data.agent : "";
+      const inT = typeof event.data.input_tokens === "number" ? event.data.input_tokens : 0;
+      const outT = typeof event.data.output_tokens === "number" ? event.data.output_tokens : 0;
+      return agent ? `usage: ${agent} in=${inT} out=${outT}` : null;
+    }
+    default:
+      return null;
+  }
+}
+function toolName(event) {
+  if (typeof event.data.tool === "string") return event.data.tool;
+  if (typeof event.data.name === "string") return event.data.name;
+  return event.message;
+}
+
+// src/commands/ask.ts
+async function runAsk(opts) {
+  const stdout = opts.stdout ?? process.stdout;
+  const stderr = opts.stderr ?? process.stderr;
+  const color = {
+    noColor: opts.noColor ?? Boolean(process.env.NO_COLOR),
+    isTTY: "isTTY" in stdout ? stdout.isTTY : false
+  };
+  const client = createMiotHarnessClient({
+    baseUrl: opts.config.harnessBaseUrl,
+    token: opts.config.token
+  });
+  const req = {
+    message: opts.message,
+    tenant_id: opts.config.tenantId,
+    user_id: opts.config.userId,
+    mode: opts.config.mode,
+    conversation_id: opts.conversationId ?? randomUUID(),
+    ...opts.config.debug ? { debug: true } : {}
+  };
+  stdout.write(
+    `${dim(`miot-chat \u2192 ${opts.config.harnessBaseUrl} (${opts.config.mode} / ${opts.config.tenantId})`, color)}
+`
+  );
+  let state = initialState(color);
+  let terminal = null;
+  let failureMessage = "";
+  let runId = "";
+  const events = [];
+  try {
+    const { run_id } = await client.runs.create(req);
+    runId = run_id;
+    for await (const event of client.runs.stream(run_id)) {
+      events.push(event);
+      const r = renderEvent(state, event);
+      state = r.state;
+      if (r.output.length > 0) stdout.write(r.output);
+      if (event.type === "run.completed") {
+        terminal = "completed";
+        break;
+      }
+      if (event.type === "run.failed") {
+        terminal = "failed";
+        failureMessage = event.message;
+        break;
+      }
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    stderr.write(`${red(`error: ${msg}`, color)}
+`);
+    return e instanceof MiotHarnessApiError ? 1 : 2;
+  }
+  if (terminal === "completed") {
+    let answer = state.pendingAnswer;
+    try {
+      const record = await client.runs.get(runId);
+      answer = record.answer;
+    } catch {
+    }
+    const finalRender = renderAuthoritativeAnswer(state, answer);
+    stdout.write(finalRender.output);
+    return 0;
+  }
+  if (terminal === "failed") {
+    const failureRender = renderRunFailure(state, failureMessage);
+    stdout.write(failureRender.output);
+    return 1;
+  }
+  stderr.write(
+    `${red("stream ended without a terminal event", color)}
+`
+  );
+  return 2;
+}
+function registerAskCommand(program2) {
+  program2.command("ask <message>").description("Send a single message, stream events, print the answer, exit.").option("--conversation <id>", "Override the conversation id for this run").action(async (message, cmdOpts) => {
+    const flags = program2.opts();
+    const config = resolveConfig({ flags });
+    const code = await runAsk({
+      message,
+      config,
+      conversationId: cmdOpts.conversation
+    });
+    process.exit(code);
+  });
+}
+
+// src/commands/login.ts
+import { InvalidArgumentError } from "commander";
+import { browserLogin } from "@microboxlabs/miot-auth/browser-oauth";
+function parseTimeoutSeconds(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new InvalidArgumentError("Expected a positive number of seconds.");
+  }
+  return parsed;
+}
+function registerLoginCommand(program2) {
+  program2.command("login").description(
+    "Log in through the browser (platform session or Auth0 PKCE) and save the token to ~/.miot-chat/config.json"
+  ).option("--login-url <url>", "Platform CLI login handoff endpoint").option("--auth-url <url>", "OAuth authorization endpoint").option("--token-url <url>", "OAuth token endpoint").option("--client-id <id>", "OAuth public client ID").option("--audience <audience>", "OAuth audience/API identifier").option("--scope <scope>", "OAuth scopes to request").option("--timeout <seconds>", "Login timeout in seconds", parseTimeoutSeconds).option("--no-open", "Print the login URL without opening the browser").action(async (opts) => {
+    const flags = program2.opts();
+    const baseUrl = flags.baseUrl ?? process.env["MIOT_CHAT_BASE_URL"];
+    if (!baseUrl) {
+      process.stderr.write(
+        "error: missing base URL. Use --base-url or MIOT_CHAT_BASE_URL.\n"
+      );
+      process.exit(3);
+    }
+    try {
+      const result = await browserLogin({
+        baseUrl,
+        ...opts.loginUrl !== void 0 && { loginUrl: opts.loginUrl },
+        ...opts.authUrl !== void 0 && { authorizationUrl: opts.authUrl },
+        ...opts.tokenUrl !== void 0 && { tokenUrl: opts.tokenUrl },
+        ...opts.clientId !== void 0 && { clientId: opts.clientId },
+        ...opts.audience !== void 0 && { audience: opts.audience },
+        ...opts.scope !== void 0 && { scope: opts.scope },
+        ...opts.timeout !== void 0 && { timeoutSeconds: opts.timeout },
+        openBrowser: opts.open
+      });
+      const profileName = flags.profile ?? "platform";
+      const existing = readConfig().profiles[profileName];
+      upsertProfile(
+        profileName,
+        {
+          baseUrl,
+          token: result.accessToken,
+          tenantId: existing?.tenantId ?? "demo-tenant",
+          userId: existing?.userId ?? "demo-user",
+          ...existing?.mode !== void 0 && { mode: existing.mode },
+          ...result.organizationId !== void 0 && {
+            orgSlug: result.organizationId
+          }
+        },
+        { makeDefault: true }
+      );
+      process.stderr.write(
+        `Logged in. Saved profile "${profileName}" (org: ${result.organizationId ?? "n/a"}) and set it as default.
+`
+      );
+      process.exit(0);
+    } catch (err) {
+      process.stderr.write(
+        `error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/resume.ts
+import { createMiotHarnessClient as createMiotHarnessClient2 } from "@microboxlabs/miot-harness-client";
+
+// src/repl/conversation.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+var FILENAME = "last-conversation";
+function conversationFilePath(configDir) {
+  return join3(configDir ?? getConfigDir(), FILENAME);
+}
+function readLastConversation(configDir) {
+  const path = conversationFilePath(configDir);
+  if (!existsSync2(path)) return null;
+  try {
+    const value = readFileSync3(path, "utf-8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeLastConversation(conversationId, configDir) {
+  const path = conversationFilePath(configDir);
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  writeFileSync2(path, `${conversationId}
+`, { mode: 384 });
+}
+
+// src/repl/loop.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { writeFileSync as writeFileSync3 } from "fs";
+import { createInterface } from "readline";
+import {
+  MiotHarnessApiError as MiotHarnessApiError2
+} from "@microboxlabs/miot-harness-client";
+
+// src/repl/slash.ts
+var AGENTIC_TENANT_LOCK = "mintral";
+var VALID_MODES2 = /* @__PURE__ */ new Set([
+  "auto",
+  "canned",
+  "meta",
+  "agentic"
+]);
+function parseSlash(line, state) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("/")) return { kind: "noop" };
+  const parts = trimmed.slice(1).split(/\s+/);
+  const head = parts[0]?.toLowerCase() ?? "";
+  const rest = parts.slice(1);
+  switch (head) {
+    case "":
+      return { kind: "invalid", reason: "empty slash command" };
+    case "exit":
+    case "quit":
+      return { kind: "exit" };
+    case "reset":
+      return { kind: "reset" };
+    case "mode": {
+      const value = rest[0];
+      if (value === void 0) {
+        return {
+          kind: "invalid",
+          reason: "usage: /mode <auto|canned|meta|agentic>"
+        };
+      }
+      if (!VALID_MODES2.has(value)) {
+        return { kind: "invalid", reason: `unknown mode: ${value}` };
+      }
+      const newMode = value;
+      return {
+        kind: "set-mode",
+        mode: newMode,
+        warnAgenticTenantMismatch: newMode === "agentic" && state.tenant !== AGENTIC_TENANT_LOCK
+      };
+    }
+    case "tenant": {
+      const value = rest[0];
+      if (value === void 0 || value.length === 0) {
+        return { kind: "invalid", reason: "usage: /tenant <id>" };
+      }
+      return {
+        kind: "set-tenant",
+        tenant: value,
+        warnAgenticTenantMismatch: state.mode === "agentic" && value !== AGENTIC_TENANT_LOCK
+      };
+    }
+    case "save": {
+      const path = rest.join(" ");
+      if (path.length === 0) {
+        return { kind: "invalid", reason: "usage: /save <file>" };
+      }
+      return { kind: "save", path };
+    }
+    default:
+      return { kind: "invalid", reason: `unknown command: /${head}` };
+  }
+}
+
+// src/repl/loop.ts
+async function runRepl(opts) {
+  const stdin = opts.stdin ?? process.stdin;
+  const stdout = opts.stdout ?? process.stdout;
+  const stderr = opts.stderr ?? process.stderr;
+  const color = {
+    noColor: opts.noColor ?? Boolean(process.env.NO_COLOR),
+    isTTY: "isTTY" in stdout ? stdout.isTTY : false
+  };
+  const session = {
+    mode: opts.config.mode,
+    tenant: opts.config.tenantId,
+    user: opts.config.userId,
+    conversationId: opts.conversationId ?? randomUUID2(),
+    debug: opts.config.debug,
+    transcript: []
+  };
+  const rl = createInterface({ input: stdin, output: stdout, terminal: false });
+  let currentAbort = null;
+  let exitCode = 0;
+  rl.on("SIGINT", () => {
+    if (currentAbort) {
+      currentAbort.abort();
+      stdout.write(`${CLEAR_LINE}${dim("aborted.", color)}
+`);
+    }
+  });
+  if (opts.greet !== false) {
+    stdout.write(
+      `${dim(`miot-chat \u2192 ${opts.config.harnessBaseUrl} (${session.mode} / ${session.tenant})`, color)}
+`
+    );
+    stdout.write(`${dim(`conversation: ${session.conversationId}`, color)}
+`);
+    warnIfAgenticMismatch(session, color, stdout);
+  }
+  const promptFn = () => promptFor(session, color);
+  rl.setPrompt(promptFn());
+  try {
+    for await (const line of iterateLines(rl, stdout, promptFn)) {
+      const slashAction = parseSlash(line, slashStateOf(session));
+      if (slashAction.kind === "noop" && line.trim().length === 0) {
+        continue;
+      }
+      if (slashAction.kind === "exit") {
+        try {
+          writeLastConversation(session.conversationId, opts.configDir);
+        } catch (e) {
+          stderr.write(
+            `${red(`could not persist last conversation: ${describeError(e)}`, color)}
+`
+          );
+        }
+        break;
+      }
+      if (slashAction.kind === "reset") {
+        session.conversationId = randomUUID2();
+        session.transcript = [];
+        stdout.write(
+          `${dim(`new conversation: ${session.conversationId}`, color)}
+`
+        );
+        rl.setPrompt(promptFn());
+        continue;
+      }
+      if (slashAction.kind === "set-mode") {
+        session.mode = slashAction.mode;
+        stdout.write(`${dim(`mode = ${session.mode}`, color)}
+`);
+        if (slashAction.warnAgenticTenantMismatch) {
+          stdout.write(
+            `${yellow(`heads-up: agentic mode is gated to tenant '${AGENTIC_TENANT_LOCK}'; current tenant is '${session.tenant}'.`, color)}
+`
+          );
+        }
+        rl.setPrompt(promptFn());
+        continue;
+      }
+      if (slashAction.kind === "set-tenant") {
+        session.tenant = slashAction.tenant;
+        stdout.write(`${dim(`tenant = ${session.tenant}`, color)}
+`);
+        if (slashAction.warnAgenticTenantMismatch) {
+          stdout.write(
+            `${yellow(`heads-up: agentic mode is gated to tenant '${AGENTIC_TENANT_LOCK}'; this run will be denied.`, color)}
+`
+          );
+        }
+        rl.setPrompt(promptFn());
+        continue;
+      }
+      if (slashAction.kind === "save") {
+        try {
+          writeFileSync3(
+            slashAction.path,
+            JSON.stringify(
+              {
+                conversation_id: session.conversationId,
+                transcript: session.transcript
+              },
+              null,
+              2
+            ),
+            { encoding: "utf-8" }
+          );
+          stdout.write(`${dim(`saved transcript to ${slashAction.path}`, color)}
+`);
+        } catch (e) {
+          stderr.write(
+            `${red(`save failed: ${describeError(e)}`, color)}
+`
+          );
+        }
+        continue;
+      }
+      if (slashAction.kind === "invalid") {
+        stderr.write(`${red(slashAction.reason, color)}
+`);
+        continue;
+      }
+      currentAbort = new AbortController();
+      try {
+        await runOneTurn(line, session, opts.client, {
+          color,
+          stdout,
+          stderr,
+          signal: currentAbort.signal
+        });
+      } catch (e) {
+        if (e.name === "AbortError") {
+        } else if (e instanceof MiotHarnessApiError2) {
+          stderr.write(`${red(`error: ${e.message}`, color)}
+`);
+          exitCode = 1;
+        } else {
+          stderr.write(`${red(`unexpected: ${describeError(e)}`, color)}
+`);
+          exitCode = 1;
+        }
+      } finally {
+        currentAbort = null;
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  return exitCode;
+}
+async function runOneTurn(prompt, session, client, ctx) {
+  const req = {
+    message: prompt,
+    tenant_id: session.tenant,
+    user_id: session.user,
+    mode: session.mode,
+    conversation_id: session.conversationId,
+    ...session.debug ? { debug: true } : {}
+  };
+  const { run_id } = await client.runs.create(req, { signal: ctx.signal });
+  let state = initialState(ctx.color);
+  let terminal = null;
+  let failureMessage = "";
+  const seenEvents = [];
+  for await (const event of client.runs.stream(run_id, { signal: ctx.signal })) {
+    seenEvents.push(event);
+    const r = renderEvent(state, event);
+    state = r.state;
+    if (r.output.length > 0) ctx.stdout.write(r.output);
+    if (event.type === "run.completed") {
+      terminal = "completed";
+      break;
+    }
+    if (event.type === "run.failed") {
+      terminal = "failed";
+      failureMessage = event.message;
+      break;
+    }
+  }
+  if (terminal === "completed") {
+    let record = null;
+    try {
+      record = await client.runs.get(run_id);
+    } catch {
+      record = null;
+    }
+    const finalRender = renderAuthoritativeAnswer(state, record?.answer ?? null);
+    ctx.stdout.write(finalRender.output);
+    session.transcript.push({ prompt, runId: run_id, record });
+    return;
+  }
+  if (terminal === "failed") {
+    const failureRender = renderRunFailure(state, failureMessage);
+    ctx.stdout.write(failureRender.output);
+    session.transcript.push({ prompt, runId: run_id, record: null });
+    return;
+  }
+  throw new Error("stream ended without a terminal event");
+}
+function slashStateOf(s) {
+  return { mode: s.mode, tenant: s.tenant };
+}
+function promptFor(s, color) {
+  const tag = `${s.conversationId.slice(0, 6)}:${s.mode}`;
+  return `${dim(`[${tag}]`, color)} > `;
+}
+function warnIfAgenticMismatch(s, color, out) {
+  if (s.mode === "agentic" && s.tenant !== AGENTIC_TENANT_LOCK) {
+    out.write(
+      `${yellow(`heads-up: agentic mode is gated to tenant '${AGENTIC_TENANT_LOCK}'; current tenant is '${s.tenant}'.`, color)}
+`
+    );
+  }
+}
+function describeError(e) {
+  if (e instanceof Error) return e.message;
+  return String(e);
+}
+async function* iterateLines(rl, stdout, prompt) {
+  stdout.write(prompt());
+  for await (const line of rl) {
+    yield line;
+    stdout.write(prompt());
+  }
+}
+
+// src/tui/runTui.ts
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/tui/App.tsx
+import { Box as Box12 } from "ink";
+import { useCallback as useCallback2, useMemo as useMemo2, useState as useState7 } from "react";
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/tui/input/Editor.tsx
+import { Box, Text, useInput } from "ink";
+import { useReducer, useState } from "react";
+
+// src/tui/input/history.ts
+import {
+  chmodSync,
+  existsSync as existsSync3,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync4
+} from "fs";
+var HISTORY_CAP = 200;
+function initialHistory() {
+  return { entries: [], cursor: -1 };
+}
+function appendHistory(store, text) {
+  if (text.trim().length === 0) return resetCursor(store);
+  const lastIdx = store.entries.length - 1;
+  if (lastIdx >= 0 && store.entries[lastIdx] === text) {
+    return resetCursor(store);
+  }
+  const next = store.entries.length >= HISTORY_CAP ? [...store.entries.slice(store.entries.length - HISTORY_CAP + 1), text] : [...store.entries, text];
+  return { entries: next, cursor: -1 };
+}
+function resetCursor(store) {
+  if (store.cursor === -1) return store;
+  return { entries: store.entries, cursor: -1 };
+}
+function navUp(store) {
+  if (store.entries.length === 0) {
+    return { store, text: null };
+  }
+  const target = store.cursor === -1 ? store.entries.length - 1 : Math.max(0, store.cursor - 1);
+  const text = store.entries[target] ?? null;
+  return { store: { entries: store.entries, cursor: target }, text };
+}
+function navDown(store) {
+  if (store.cursor === -1) {
+    return { store, text: null };
+  }
+  const next = store.cursor + 1;
+  if (next >= store.entries.length) {
+    return { store: { entries: store.entries, cursor: -1 }, text: "" };
+  }
+  const text = store.entries[next] ?? null;
+  return { store: { entries: store.entries, cursor: next }, text };
+}
+
+// src/tui/input/keymap.ts
+function mapKey(input, key) {
+  if (key.ctrl && input === "c") return { kind: "CANCEL" };
+  if (key.return && key.meta) return { kind: "NEWLINE" };
+  if (key.return) return { kind: "SUBMIT" };
+  if (key.backspace) return { kind: "BACKSPACE" };
+  if (key.delete) return { kind: "DELETE_FORWARD" };
+  if (key.leftArrow && key.ctrl) return { kind: "MOVE_WORD_LEFT" };
+  if (key.rightArrow && key.ctrl) return { kind: "MOVE_WORD_RIGHT" };
+  if (key.leftArrow) return { kind: "MOVE_LEFT" };
+  if (key.rightArrow) return { kind: "MOVE_RIGHT" };
+  if (key.upArrow) return { kind: "MOVE_UP" };
+  if (key.downArrow) return { kind: "MOVE_DOWN" };
+  if (key.ctrl && input === "a") return { kind: "MOVE_HOME" };
+  if (key.ctrl && input === "e") return { kind: "MOVE_END" };
+  if (key.ctrl && input === "k") return { kind: "KILL_LINE" };
+  if (key.tab) return null;
+  if (key.escape) return null;
+  if (key.pageUp || key.pageDown) return null;
+  if (input.length > 0 && !key.ctrl && !key.meta) {
+    return { kind: "INSERT", text: input };
+  }
+  return null;
+}
+
+// src/tui/input/reducer.ts
+var WORD_RE = /[A-Za-z0-9_]/;
+function initialEditor() {
+  return { lines: [""], cursor: { row: 0, col: 0 }, selectionAnchor: null };
+}
+function bufferText(state) {
+  return state.lines.join("\n");
+}
+function applyEditor(state, action) {
+  switch (action.kind) {
+    case "INSERT":
+      return insertAtCursor(state, action.text);
+    case "BACKSPACE":
+      return backspace(state);
+    case "DELETE_FORWARD":
+      return deleteForward(state);
+    case "MOVE_LEFT":
+      return moveLeft(state);
+    case "MOVE_RIGHT":
+      return moveRight(state);
+    case "MOVE_UP":
+      return moveUp(state);
+    case "MOVE_DOWN":
+      return moveDown(state);
+    case "MOVE_WORD_LEFT":
+      return moveWordLeft(state);
+    case "MOVE_WORD_RIGHT":
+      return moveWordRight(state);
+    case "MOVE_HOME":
+      return setCursor(state, state.cursor.row, 0);
+    case "MOVE_END":
+      return setCursor(state, state.cursor.row, lineAt(state, state.cursor.row).length);
+    case "MOVE_DOC_HOME":
+      return setCursor(state, 0, 0);
+    case "MOVE_DOC_END": {
+      const lastRow = state.lines.length - 1;
+      return setCursor(state, lastRow, lineAt(state, lastRow).length);
+    }
+    case "NEWLINE":
+      return splitLine(state);
+    case "KILL_LINE":
+      return killLine(state);
+    case "PASTE":
+      return pasteAtCursor(state, action.text);
+    case "CLEAR":
+      return initialEditor();
+    case "SET_TEXT":
+      return setText(action.text);
+  }
+}
+function lineAt(state, row) {
+  return state.lines[row] ?? "";
+}
+function setCursor(state, row, col) {
+  return { ...state, cursor: { row, col } };
+}
+function insertAtCursor(state, text) {
+  const { row, col } = state.cursor;
+  const line = lineAt(state, row);
+  const next = line.slice(0, col) + text + line.slice(col);
+  const lines = state.lines.slice();
+  lines[row] = next;
+  return { ...state, lines, cursor: { row, col: col + text.length } };
+}
+function backspace(state) {
+  const { row, col } = state.cursor;
+  if (col > 0) {
+    const line = lineAt(state, row);
+    const next = line.slice(0, col - 1) + line.slice(col);
+    const lines2 = state.lines.slice();
+    lines2[row] = next;
+    return { ...state, lines: lines2, cursor: { row, col: col - 1 } };
+  }
+  if (row === 0) return state;
+  const prev = lineAt(state, row - 1);
+  const curr = lineAt(state, row);
+  const merged = prev + curr;
+  const lines = state.lines.slice();
+  lines.splice(row - 1, 2, merged);
+  return { ...state, lines, cursor: { row: row - 1, col: prev.length } };
+}
+function deleteForward(state) {
+  const { row, col } = state.cursor;
+  const line = lineAt(state, row);
+  if (col < line.length) {
+    const next = line.slice(0, col) + line.slice(col + 1);
+    const lines2 = state.lines.slice();
+    lines2[row] = next;
+    return { ...state, lines: lines2 };
+  }
+  if (row >= state.lines.length - 1) return state;
+  const merged = line + lineAt(state, row + 1);
+  const lines = state.lines.slice();
+  lines.splice(row, 2, merged);
+  return { ...state, lines };
+}
+function moveLeft(state) {
+  const { row, col } = state.cursor;
+  if (col > 0) return setCursor(state, row, col - 1);
+  if (row === 0) return state;
+  return setCursor(state, row - 1, lineAt(state, row - 1).length);
+}
+function moveRight(state) {
+  const { row, col } = state.cursor;
+  const line = lineAt(state, row);
+  if (col < line.length) return setCursor(state, row, col + 1);
+  if (row >= state.lines.length - 1) return state;
+  return setCursor(state, row + 1, 0);
+}
+function moveUp(state) {
+  const { row, col } = state.cursor;
+  if (row === 0) return setCursor(state, 0, 0);
+  const target = lineAt(state, row - 1);
+  return setCursor(state, row - 1, Math.min(col, target.length));
+}
+function moveDown(state) {
+  const { row, col } = state.cursor;
+  if (row >= state.lines.length - 1) {
+    return setCursor(state, row, lineAt(state, row).length);
+  }
+  const target = lineAt(state, row + 1);
+  return setCursor(state, row + 1, Math.min(col, target.length));
+}
+function isWordChar(ch) {
+  return WORD_RE.test(ch);
+}
+function moveWordLeft(state) {
+  let { row, col } = state.cursor;
+  if (col === 0) {
+    if (row === 0) return state;
+    row -= 1;
+    col = lineAt(state, row).length;
+  }
+  const line = lineAt(state, row);
+  let i = col;
+  while (i > 0 && !isWordChar(line.charAt(i - 1))) i -= 1;
+  while (i > 0 && isWordChar(line.charAt(i - 1))) i -= 1;
+  return setCursor(state, row, i);
+}
+function moveWordRight(state) {
+  const { row, col } = state.cursor;
+  const line = lineAt(state, row);
+  if (col >= line.length) {
+    if (row >= state.lines.length - 1) return state;
+    return setCursor(state, row + 1, 0);
+  }
+  let i = col;
+  while (i < line.length && isWordChar(line.charAt(i))) i += 1;
+  while (i < line.length && !isWordChar(line.charAt(i))) i += 1;
+  return setCursor(state, row, i);
+}
+function splitLine(state) {
+  const { row, col } = state.cursor;
+  const line = lineAt(state, row);
+  const before = line.slice(0, col);
+  const after = line.slice(col);
+  const lines = state.lines.slice();
+  lines.splice(row, 1, before, after);
+  return { ...state, lines, cursor: { row: row + 1, col: 0 } };
+}
+function killLine(state) {
+  const { row, col } = state.cursor;
+  const line = lineAt(state, row);
+  if (col < line.length) {
+    const lines2 = state.lines.slice();
+    lines2[row] = line.slice(0, col);
+    return { ...state, lines: lines2 };
+  }
+  if (row >= state.lines.length - 1) return state;
+  const merged = line + lineAt(state, row + 1);
+  const lines = state.lines.slice();
+  lines.splice(row, 2, merged);
+  return { ...state, lines };
+}
+function pasteAtCursor(state, text) {
+  if (!text.includes("\n")) return insertAtCursor(state, text);
+  const segments = text.split("\n");
+  const { row, col } = state.cursor;
+  const line = lineAt(state, row);
+  const before = line.slice(0, col);
+  const after = line.slice(col);
+  const head = segments[0] ?? "";
+  const tail = segments[segments.length - 1] ?? "";
+  const middle = segments.slice(1, -1);
+  const lines = state.lines.slice();
+  const newLines = [before + head, ...middle, tail + after];
+  lines.splice(row, 1, ...newLines);
+  const newRow = row + newLines.length - 1;
+  const newCol = tail.length;
+  return { ...state, lines, cursor: { row: newRow, col: newCol } };
+}
+function setText(text) {
+  if (text.length === 0) return initialEditor();
+  const lines = text.split("\n");
+  const lastRow = lines.length - 1;
+  const lastLine = lines[lastRow] ?? "";
+  return {
+    lines,
+    cursor: { row: lastRow, col: lastLine.length },
+    selectionAnchor: null
+  };
+}
+
+// src/tui/input/Editor.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function Editor(props) {
+  const promptPrefix = props.prompt ?? "\u203A ";
+  const [editor, dispatch] = useReducer(
+    (state, action) => {
+      if (action.kind === "SUBMIT" || action.kind === "CANCEL") {
+        return state;
+      }
+      return applyEditor(state, action);
+    },
+    initialEditor()
+  );
+  const [history, setHistory] = useState(
+    props.initialHistory ?? initialHistory()
+  );
+  function handle(action) {
+    if (action.kind === "CANCEL") {
+      if (props.onCancel) props.onCancel();
+      return;
+    }
+    if (action.kind === "SUBMIT") {
+      const text = bufferText(editor);
+      if (text.trim().length === 0) return;
+      setHistory(appendHistory(history, text));
+      dispatch({ kind: "CLEAR" });
+      props.onSubmit(text);
+      return;
+    }
+    if (action.kind === "MOVE_UP" && editor.cursor.row === 0) {
+      const r = navUp(history);
+      if (r.text !== null) {
+        setHistory(r.store);
+        dispatch({ kind: "SET_TEXT", text: r.text });
+      }
+      return;
+    }
+    if (action.kind === "MOVE_DOWN" && editor.cursor.row === editor.lines.length - 1) {
+      const r = navDown(history);
+      if (r.text !== null) {
+        setHistory(r.store);
+        dispatch({ kind: "SET_TEXT", text: r.text });
+      }
+      return;
+    }
+    dispatch(action);
+  }
+  useInput(
+    (input, key) => {
+      const action = mapKey(input, key);
+      if (action) handle(action);
+    },
+    { isActive: props.isFocused ?? true }
+  );
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: editor.lines.map((line, row) => /* @__PURE__ */ jsxs(Text, { children: [
+    row === 0 ? promptPrefix : "  ",
+    renderLine(line, row === editor.cursor.row ? editor.cursor.col : null)
+  ] }, row)) });
+}
+function renderLine(line, cursorCol) {
+  if (cursorCol === null) return line.length > 0 ? line : " ";
+  if (cursorCol >= line.length) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      line,
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " })
+    ] });
+  }
+  const before = line.slice(0, cursorCol);
+  const at = line.charAt(cursorCol);
+  const after = line.slice(cursorCol + 1);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    before,
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
+    after
+  ] });
+}
+
+// src/tui/header/Header.tsx
+import { Box as Box2, Text as Text3 } from "ink";
+
+// src/tui/session/agentic.ts
+var AGENTIC_TENANT_LOCK2 = "mintral";
+function isAgenticTenantMismatch(mode, tenant) {
+  return mode === "agentic" && tenant !== AGENTIC_TENANT_LOCK2;
+}
+
+// src/tui/transcript/Spinner.tsx
+import { Text as Text2 } from "ink";
+import { useEffect, useState as useState2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var MIN_INTERVAL_MS = 50;
+function Spinner(props) {
+  const interval = Math.max(MIN_INTERVAL_MS, props.intervalMs ?? 125);
+  const [frame, setFrame] = useState2(0);
+  useEffect(() => {
+    const id = setInterval(() => {
+      setFrame((f) => (f + 1) % FRAMES.length);
+    }, interval);
+    return () => {
+      clearInterval(id);
+    };
+  }, [interval]);
+  return /* @__PURE__ */ jsx2(Text2, { color: props.color, children: FRAMES[frame] });
+}
+
+// src/tui/header/Header.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var SEPARATOR = " \xB7 ";
+function Header(props) {
+  const { meta, streaming, pendingApprovals } = props;
+  const shortConv = meta.conversationId.slice(0, 8);
+  const agenticWarn = isAgenticTenantMismatch(meta.mode, meta.tenantId);
+  const chips = [];
+  chips.push(/* @__PURE__ */ jsxs2(Text3, { children: [
+    "tenant=",
+    meta.tenantId
+  ] }, "tenant"));
+  chips.push(/* @__PURE__ */ jsxs2(Text3, { children: [
+    "user=",
+    meta.userId
+  ] }, "user"));
+  chips.push(/* @__PURE__ */ jsxs2(Text3, { children: [
+    "conv=",
+    shortConv
+  ] }, "conv"));
+  chips.push(
+    /* @__PURE__ */ jsxs2(Text3, { color: agenticWarn ? "yellow" : void 0, children: [
+      agenticWarn ? "\u26A0 " : "",
+      "mode=",
+      meta.mode
+    ] }, "mode")
+  );
+  chips.push(/* @__PURE__ */ jsx3(Text3, { dimColor: true, children: meta.baseUrl }, "url"));
+  if (meta.profileName) {
+    chips.push(/* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
+      "profile=",
+      meta.profileName
+    ] }, "profile"));
+  }
+  if (pendingApprovals > 0) {
+    chips.push(
+      /* @__PURE__ */ jsxs2(Text3, { color: "yellow", children: [
+        "approvals=",
+        pendingApprovals
+      ] }, "appr")
+    );
+  }
+  if (typeof props.turns === "number") {
+    chips.push(/* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
+      "turns=",
+      props.turns
+    ] }, "turns"));
+  }
+  if (typeof props.approxTokens === "number") {
+    const pct = typeof props.contextPercent === "number" ? ` (${props.contextPercent}%)` : "";
+    chips.push(
+      /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
+        "ctx\u2248",
+        props.approxTokens,
+        "tok",
+        pct
+      ] }, "tok")
+    );
+  }
+  if (props.usageTotals && (props.usageTotals.inputTokens > 0 || props.usageTotals.outputTokens > 0)) {
+    const u = props.usageTotals;
+    const cost = u.costUsd > 0 ? ` $${u.costUsd.toFixed(4)}` : "";
+    chips.push(
+      /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
+        "usage=",
+        u.inputTokens,
+        "\u2192",
+        u.outputTokens,
+        cost
+      ] }, "usage")
+    );
+  }
+  if (streaming) {
+    chips.push(/* @__PURE__ */ jsx3(Spinner, { color: "cyan" }, "spinner"));
+  }
+  return /* @__PURE__ */ jsx3(Box2, { borderStyle: "round", paddingX: 1, flexDirection: "row", flexWrap: "wrap", children: interpose(chips, (i) => /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: SEPARATOR }, `sep-${i}`)) });
+}
+function interpose(nodes, sep) {
+  const out = [];
+  nodes.forEach((node, i) => {
+    if (i > 0) out.push(sep(i));
+    out.push(node);
+  });
+  return out;
+}
+
+// src/tui/transcript/Transcript.tsx
+import { Box as Box6, Text as Text7 } from "ink";
+
+// src/tui/transcript/AssistantTurn.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function AssistantTurn(props) {
+  const { text, status } = props.item;
+  const color = status === "failed" ? "red" : status === "complete" ? "green" : "white";
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", marginTop: 1, children: [
+    status === "streaming" ? /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      /* @__PURE__ */ jsx4(Spinner, { color: "cyan" }),
+      /* @__PURE__ */ jsxs3(Text4, { color, bold: true, children: [
+        " ",
+        "miot",
+        " "
+      ] })
+    ] }) : /* @__PURE__ */ jsxs3(Text4, { color, bold: true, children: [
+      status === "failed" ? "\u2717 " : "\u2713 ",
+      "miot",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color, children: text })
+  ] });
+}
+
+// src/tui/transcript/ToolCall.tsx
+import { Box as Box4, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function ToolCall(props) {
+  const { name, status, message } = props.item;
+  const color = status === "failed" ? "red" : status === "ok" ? "green" : "yellow";
+  const glyph = status === "running" ? null : status === "ok" ? "\u2713" : "\u2717";
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx5(Text5, { color, children: glyph !== null ? `${glyph} ` : "" }),
+    status === "running" ? /* @__PURE__ */ jsx5(Spinner, { color }) : null,
+    /* @__PURE__ */ jsxs4(Text5, { color, children: [
+      " ",
+      "tool: ",
+      name,
+      message && status !== "running" ? ` \u2014 ${message}` : ""
+    ] })
+  ] });
+}
+
+// src/tui/transcript/UserTurn.tsx
+import { Box as Box5, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function UserTurn(props) {
+  const { text } = props.item;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "row", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs5(Text6, { color: "cyan", bold: true, children: [
+      "you",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { children: text })
+  ] });
+}
+
+// src/tui/transcript/Transcript.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function Transcript(props) {
+  const activeChainIdx = props.isStreaming ? findActiveChainIndex(props.items) : -1;
+  return /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", children: props.items.map((item, i) => /* @__PURE__ */ jsx7(
+    TranscriptItemView,
+    {
+      item,
+      isActive: i === activeChainIdx
+    },
+    item.id
+  )) });
+}
+function findActiveChainIndex(items) {
+  for (let i = items.length - 1; i >= 0; i -= 1) {
+    const item = items[i];
+    if (!item) continue;
+    if (item.kind === "route" || item.kind === "plan" || item.kind === "agent" || item.kind === "artifact" || item.kind === "freshness") {
+      return i;
+    }
+    if (item.kind === "user") return -1;
+    if (item.kind === "assistant") return -1;
+  }
+  return -1;
+}
+function TranscriptItemView(props) {
+  const { item, isActive } = props;
+  switch (item.kind) {
+    case "user":
+      return /* @__PURE__ */ jsx7(UserTurn, { item });
+    case "assistant":
+      return /* @__PURE__ */ jsx7(AssistantTurn, { item });
+    case "tool":
+      return /* @__PURE__ */ jsx7(ToolCall, { item });
+    case "route":
+      return /* @__PURE__ */ jsx7(ChainRow, { prefix: "route:", isActive, children: item.route });
+    case "agent":
+      return /* @__PURE__ */ jsx7(ChainRow, { prefix: "agent:", isActive, children: item.agent });
+    case "thinking":
+      return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  \u22EE " }),
+        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: item.text })
+      ] });
+    case "plan":
+      return /* @__PURE__ */ jsx7(ChainRow, { prefix: "plan:", isActive, children: item.message });
+    case "freshness":
+      return /* @__PURE__ */ jsxs6(Text7, { color: "yellow", children: [
+        "\u26A0 ",
+        item.message
+      ] });
+    case "artifact":
+      return /* @__PURE__ */ jsx7(ChainRow, { prefix: "artifact:", isActive, children: item.artifactKind });
+    case "system":
+      return /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: item.text });
+  }
+}
+function ChainRow(props) {
+  if (props.isActive) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx7(Spinner, { color: "cyan" }),
+      /* @__PURE__ */ jsxs6(Text7, { color: "cyan", bold: true, children: [
+        " ",
+        props.prefix,
+        " ",
+        props.children
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+    "\xB7 ",
+    props.prefix,
+    " ",
+    props.children
+  ] });
+}
+
+// src/tui/modals/ContextModal.tsx
+import { Box as Box7, Text as Text8, useInput as useInput2 } from "ink";
+
+// src/tui/session/selectors.ts
+function isStreaming(state) {
+  return state.currentRunId !== null;
+}
+function pendingApprovalCount(state) {
+  return state.pendingApprovals.length;
+}
+function turnCount(state) {
+  return state.transcript.filter((i) => i.kind === "user").length;
+}
+function approxTokenCount(state) {
+  let chars = 0;
+  for (const item of state.transcript) {
+    switch (item.kind) {
+      case "user":
+      case "system":
+        chars += item.text.length;
+        break;
+      case "assistant":
+        chars += item.text.length;
+        break;
+      case "tool":
+        chars += item.name.length + (item.message?.length ?? 0);
+        break;
+      case "route":
+        chars += item.route.length;
+        break;
+      case "agent":
+        chars += item.agent.length;
+        break;
+      case "plan":
+      case "freshness":
+        chars += item.message.length;
+        break;
+      case "artifact":
+        chars += item.artifactKind.length;
+        break;
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+var ASSUMED_CONTEXT_WINDOW = 2e5;
+function contextPercent(state) {
+  return Math.min(
+    100,
+    Math.round(approxTokenCount(state) / ASSUMED_CONTEXT_WINDOW * 100)
+  );
+}
+
+// src/tui/modals/ContextModal.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function ContextModal(props) {
+  const { session, lastRunId } = props;
+  useInput2(
+    (_input, key) => {
+      if (key.escape || key.return) props.onClose();
+    },
+    { isActive: props.isFocused ?? true }
+  );
+  const fields = [
+    ["tenant", session.meta.tenantId],
+    ["user", session.meta.userId],
+    ["conv", session.meta.conversationId],
+    ["mode", session.meta.mode],
+    ["baseUrl", session.meta.baseUrl]
+  ];
+  if (session.meta.profileName) {
+    fields.push(["profile", session.meta.profileName]);
+  }
+  fields.push(["turns", String(turnCount(session))]);
+  fields.push(["last run", lastRunId ?? "(none)"]);
+  fields.push([
+    "pending approvals",
+    String(session.pendingApprovals.length)
+  ]);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { bold: true, children: "session context" }),
+    fields.map(([key, value]) => /* @__PURE__ */ jsxs7(Text8, { children: [
+      key.padEnd(18),
+      " ",
+      value
+    ] }, key)),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "esc/enter to close" })
+  ] });
+}
+
+// src/tui/modals/ResumePicker.tsx
+import { Box as Box8, Text as Text9, useInput as useInput3 } from "ink";
+import { useState as useState3 } from "react";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function ResumePicker(props) {
+  const maxRows = props.maxRows ?? 10;
+  const [index, setIndex] = useState3(0);
+  const summaries = props.summaries;
+  const cap = Math.max(0, summaries.length - 1);
+  useInput3(
+    (_input, key) => {
+      if (key.escape) {
+        props.onCancel();
+        return;
+      }
+      if (key.upArrow) {
+        setIndex((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setIndex((i) => Math.min(cap, i + 1));
+        return;
+      }
+      if (key.return) {
+        const chosen = summaries[Math.min(index, cap)];
+        if (chosen) props.onSelect(chosen.id);
+      }
+    },
+    { isActive: props.isFocused ?? true }
+  );
+  if (summaries.length === 0) {
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: true, children: "resume session" }),
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "(no saved sessions)" }),
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "esc to close" })
+    ] });
+  }
+  const visible = summaries.slice(0, maxRows);
+  const truncated = summaries.length - visible.length;
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx9(Text9, { bold: true, children: "resume session" }),
+    visible.map((s, i) => /* @__PURE__ */ jsx9(Text9, { inverse: i === index, children: summarize(s) }, s.id)),
+    truncated > 0 ? /* @__PURE__ */ jsxs8(Text9, { dimColor: true, children: [
+      "\u2026 ",
+      truncated,
+      " more"
+    ] }) : null,
+    /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "\u2191\u2193 navigate \xB7 enter select \xB7 esc cancel" })
+  ] });
+}
+function summarize(s) {
+  const idShort = s.id.slice(0, 8);
+  const turns = `${s.lastTurn} turn${s.lastTurn === 1 ? "" : "s"}`;
+  const date = new Date(s.mtime).toISOString().slice(0, 16).replace("T", " ");
+  const prompt = s.lastPrompt ? truncate(s.lastPrompt, 40) : "(empty)";
+  return `${date}  ${idShort}  ${turns.padEnd(8)}  ${prompt}`;
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1)}\u2026`;
+}
+
+// src/tui/modals/ThemePicker.tsx
+import { Box as Box9, Text as Text10, useInput as useInput4 } from "ink";
+import { useState as useState4 } from "react";
+
+// src/tui/theme/themes.ts
+var DARK_THEME = {
+  accent: "cyan",
+  assistant: "white",
+  user: "cyan",
+  dim: "gray",
+  warn: "yellow",
+  err: "red",
+  ok: "green",
+  border: "gray",
+  prompt: "cyan",
+  spinner: "cyan"
+};
+var LIGHT_THEME = {
+  accent: "blue",
+  assistant: "black",
+  user: "blue",
+  dim: "gray",
+  warn: "yellow",
+  err: "red",
+  ok: "green",
+  border: "gray",
+  prompt: "blue",
+  spinner: "blue"
+};
+var HIGH_CONTRAST_THEME = {
+  accent: "white",
+  assistant: "white",
+  user: "white",
+  dim: "white",
+  warn: "yellow",
+  err: "red",
+  ok: "green",
+  border: "white",
+  prompt: "white",
+  spinner: "white"
+};
+var BUILTIN_THEMES = {
+  dark: DARK_THEME,
+  light: LIGHT_THEME,
+  "high-contrast": HIGH_CONTRAST_THEME
+};
+var DEFAULT_THEME_NAME = "dark";
+function builtinThemeNames() {
+  return Object.keys(BUILTIN_THEMES).sort();
+}
+
+// src/tui/modals/ThemePicker.tsx
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function ThemePicker(props) {
+  const names = builtinThemeNames();
+  const initial = props.initialName ? Math.max(0, names.indexOf(props.initialName)) : 0;
+  const [index, setIndex] = useState4(initial);
+  const cap = names.length - 1;
+  useInput4(
+    (_input, key) => {
+      if (key.escape) {
+        props.onCancel();
+        return;
+      }
+      if (key.upArrow) {
+        setIndex((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setIndex((i) => Math.min(cap, i + 1));
+        return;
+      }
+      if (key.return) {
+        const name = names[Math.min(index, cap)];
+        if (name) props.onSelect(name);
+      }
+    },
+    { isActive: props.isFocused ?? true }
+  );
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx10(Text10, { bold: true, children: "theme" }),
+    names.map((name, i) => {
+      const t = BUILTIN_THEMES[name];
+      const sample = t ? `accent=${t.accent} user=${t.user}` : "";
+      return /* @__PURE__ */ jsxs9(Text10, { inverse: i === index, children: [
+        name.padEnd(15),
+        " ",
+        sample
+      ] }, name);
+    }),
+    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u2191\u2193 navigate \xB7 enter apply \xB7 esc cancel" })
+  ] });
+}
+
+// src/tui/modals/ApprovalModal.tsx
+import { Box as Box10, Text as Text11, useInput as useInput5 } from "ink";
+
+// src/tui/session/approvals.ts
+var APPROVALS_UI_ENV = "MIOT_CHAT_APPROVALS_UI";
+function isApprovalsUiEnabled(env = process.env) {
+  const raw = env[APPROVALS_UI_ENV];
+  if (raw === void 0) return false;
+  return raw === "1" || raw.toLowerCase() === "true";
+}
+var APPROVAL_REPLY_PLACEHOLDER = "approval reply not yet supported by harness";
+
+// src/tui/modals/ApprovalModal.tsx
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+function ApprovalModal(props) {
+  const { approval, onResolve } = props;
+  useInput5(
+    (input, key) => {
+      const ch = input.toLowerCase();
+      if (key.escape) onResolve("later", approval.id);
+      else if (ch === "y") onResolve("approve", approval.id);
+      else if (ch === "n") onResolve("deny", approval.id);
+    },
+    { isActive: props.isFocused ?? true }
+  );
+  const data = JSON.stringify(approval.data, null, 2);
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx11(Text11, { bold: true, color: "yellow", children: "approval requested" }),
+    /* @__PURE__ */ jsx11(Text11, { children: approval.message || "(no message)" }),
+    /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: data }),
+    /* @__PURE__ */ jsx11(Text11, { children: "[Y] approve  [N] deny  [Esc] later" }),
+    /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: APPROVAL_REPLY_PLACEHOLDER })
+  ] });
+}
+
+// src/tui/modals/RunsPicker.tsx
+import { Box as Box11, Text as Text12, useInput as useInput6 } from "ink";
+import { useState as useState5 } from "react";
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+function RunsPicker(props) {
+  const maxRows = props.maxRows ?? 10;
+  const [index, setIndex] = useState5(0);
+  const cap = Math.max(0, props.runs.length - 1);
+  useInput6(
+    (_input, key) => {
+      if (key.escape) {
+        props.onCancel();
+        return;
+      }
+      if (key.upArrow) {
+        setIndex((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setIndex((i) => Math.min(cap, i + 1));
+        return;
+      }
+      if (key.return) {
+        const chosen = props.runs[Math.min(index, cap)];
+        if (chosen) props.onSelect(chosen.runId);
+      }
+    },
+    { isActive: props.isFocused ?? true }
+  );
+  if (props.runs.length === 0) {
+    return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+      /* @__PURE__ */ jsx12(Text12, { bold: true, children: "recent runs" }),
+      /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "(no runs in this session)" }),
+      /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "esc to close" })
+    ] });
+  }
+  const visible = props.runs.slice(0, maxRows);
+  const truncated = props.runs.length - visible.length;
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Text12, { bold: true, children: "recent runs" }),
+    visible.map((r, i) => /* @__PURE__ */ jsx12(Text12, { inverse: i === index, children: formatRow(r) }, r.runId)),
+    truncated > 0 ? /* @__PURE__ */ jsxs11(Text12, { dimColor: true, children: [
+      "\u2026 ",
+      truncated,
+      " more"
+    ] }) : null,
+    /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "\u2191\u2193 navigate \xB7 enter replay \xB7 esc cancel" })
+  ] });
+}
+function formatRow(r) {
+  const short = r.runId.slice(0, 12);
+  const status = r.status === "unknown" ? "?" : statusGlyph(r.status);
+  const prompt = r.prompt ? truncate2(r.prompt, 50) : "(no prompt)";
+  return `${status} ${short.padEnd(12)}  ${prompt}`;
+}
+function statusGlyph(s) {
+  if (s === "complete") return "\u2713";
+  if (s === "failed") return "\u2717";
+  return "\u2026";
+}
+function truncate2(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1)}\u2026`;
+}
+function summarizeRuns(state) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = state.transcript.length - 1; i >= 0; i -= 1) {
+    const item = state.transcript[i];
+    if (!item || item.kind !== "assistant") continue;
+    if (seen.has(item.runId)) continue;
+    seen.add(item.runId);
+    const prompt = findPrecedingPrompt(state.transcript, i);
+    out.push({ runId: item.runId, prompt, status: item.status });
+  }
+  return out;
+}
+function findPrecedingPrompt(items, startAt) {
+  for (let i = startAt - 1; i >= 0; i -= 1) {
+    const item = items[i];
+    if (item && item.kind === "user") return item.text;
+  }
+  return null;
+}
+
+// src/tui/theme/ThemeProvider.tsx
+import { createContext, useContext, useMemo, useState as useState6 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var ThemeContext = createContext({
+  theme: DARK_THEME,
+  setTheme: () => void 0
+});
+function ThemeProvider(props) {
+  const [theme, setTheme] = useState6(
+    props.initialTheme ?? DARK_THEME
+  );
+  const value = useMemo(
+    () => ({ theme, setTheme }),
+    [theme]
+  );
+  return /* @__PURE__ */ jsx13(ThemeContext.Provider, { value, children: props.children });
+}
+function useTheme() {
+  return useContext(ThemeContext);
+}
+
+// src/tui/theme/loadUserTheme.ts
+function loadUserTheme(config) {
+  if (config === void 0 || config === null) {
+    return { theme: DARK_THEME, warning: null };
+  }
+  if (typeof config === "string") {
+    return resolveByName(config);
+  }
+  if (typeof config !== "object") {
+    return {
+      theme: DARK_THEME,
+      warning: `theme config must be a string or object, got ${typeof config}`
+    };
+  }
+  const name = config.name ?? DEFAULT_THEME_NAME;
+  const baseResult = resolveByName(name);
+  const overrides = config.tokens ?? {};
+  return {
+    theme: { ...baseResult.theme, ...overrides },
+    warning: baseResult.warning
+  };
+}
+function resolveByName(name) {
+  const found = BUILTIN_THEMES[name];
+  if (found) return { theme: found, warning: null };
+  return {
+    theme: DARK_THEME,
+    warning: `unknown theme: ${name}, falling back to ${DEFAULT_THEME_NAME}`
+  };
+}
+
+// src/tui/useSession.ts
+import { useCallback, useEffect as useEffect2, useReducer as useReducer2, useRef } from "react";
+import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+
+// src/tui/transcript/project.ts
+function applyHarnessEvent(slice, event, runId, ctx) {
+  switch (event.type) {
+    case "run.started":
+      return { ...slice, currentRunId: runId };
+    case "run.completed":
+    case "run.failed":
+      return slice;
+    case "answer.completed":
+      return upsertAssistantItem(slice, event, runId, ctx);
+    case "tool.started":
+      return appendToolItem(slice, event, "running", ctx);
+    case "tool.completed":
+      return flipOrAppendTool(slice, event, "ok", ctx);
+    case "tool.failed":
+      return flipOrAppendTool(slice, event, "failed", ctx);
+    case "approval.requested": {
+      const ts = ctx.now();
+      const message = event.message || "approval needed";
+      const systemItem = {
+        kind: "system",
+        id: ctx.uuid(),
+        text: `approval requested: ${message}`,
+        ts
+      };
+      const approval = {
+        id: event.id,
+        runId,
+        message: event.message,
+        data: event.data,
+        ts
+      };
+      return {
+        ...slice,
+        transcript: [...slice.transcript, systemItem],
+        pendingApprovals: [...slice.pendingApprovals, approval]
+      };
+    }
+    case "route.selected": {
+      const route = typeof event.data.route === "string" && event.data.route.length > 0 ? event.data.route : event.message;
+      if (!route) return slice;
+      return appendItem(slice, {
+        kind: "route",
+        id: ctx.uuid(),
+        route,
+        ts: ctx.now()
+      });
+    }
+    case "agent.turn":
+    case "agent.started": {
+      const agent = typeof event.data.agent === "string" && event.data.agent.length > 0 ? event.data.agent : event.message;
+      if (!agent) return slice;
+      return appendItem(slice, {
+        kind: "agent",
+        id: ctx.uuid(),
+        agent,
+        ts: ctx.now()
+      });
+    }
+    case "agent.completed":
+      return slice;
+    case "thinking.delta": {
+      const delta = typeof event.data.delta === "string" ? event.data.delta : "";
+      if (!delta) return slice;
+      const agent = typeof event.data.agent === "string" ? event.data.agent : "synthesizer";
+      const existingId = slice.currentThinkingItemId;
+      if (existingId) {
+        return {
+          ...slice,
+          transcript: slice.transcript.map(
+            (item2) => item2.kind === "thinking" && item2.id === existingId ? { ...item2, text: item2.text + delta } : item2
+          )
+        };
+      }
+      const id = ctx.uuid();
+      const item = {
+        kind: "thinking",
+        id,
+        agent,
+        text: delta,
+        status: "streaming",
+        ts: ctx.now()
+      };
+      return {
+        ...slice,
+        currentThinkingItemId: id,
+        transcript: [...slice.transcript, item]
+      };
+    }
+    case "thinking.completed": {
+      const existingId = slice.currentThinkingItemId;
+      if (!existingId) return slice;
+      return {
+        ...slice,
+        currentThinkingItemId: null,
+        transcript: slice.transcript.map(
+          (item) => item.kind === "thinking" && item.id === existingId ? { ...item, status: "complete" } : item
+        )
+      };
+    }
+    case "usage.recorded": {
+      const inT = typeof event.data.input_tokens === "number" ? event.data.input_tokens : 0;
+      const outT = typeof event.data.output_tokens === "number" ? event.data.output_tokens : 0;
+      const cacheR = typeof event.data.cache_read_input_tokens === "number" ? event.data.cache_read_input_tokens : 0;
+      const cacheC = typeof event.data.cache_creation_input_tokens === "number" ? event.data.cache_creation_input_tokens : 0;
+      const cost = typeof event.data.cost_usd === "number" ? event.data.cost_usd : 0;
+      const agent = typeof event.data.agent === "string" ? event.data.agent : null;
+      return {
+        ...slice,
+        usageTotals: {
+          inputTokens: slice.usageTotals.inputTokens + inT,
+          outputTokens: slice.usageTotals.outputTokens + outT,
+          cacheReadTokens: slice.usageTotals.cacheReadTokens + cacheR,
+          cacheCreationTokens: slice.usageTotals.cacheCreationTokens + cacheC,
+          costUsd: slice.usageTotals.costUsd + cost,
+          lastAgent: agent,
+          lastCostUsd: typeof event.data.cost_usd === "number" ? event.data.cost_usd : null
+        }
+      };
+    }
+    case "plan.created":
+      return appendItem(slice, {
+        kind: "plan",
+        id: ctx.uuid(),
+        message: event.message || "plan ready",
+        ts: ctx.now()
+      });
+    case "freshness.warning":
+      return appendItem(slice, {
+        kind: "freshness",
+        id: ctx.uuid(),
+        message: event.message || "stale data",
+        ts: ctx.now()
+      });
+    case "artifact.created": {
+      const artifactKind = typeof event.data.kind === "string" && event.data.kind.length > 0 ? event.data.kind : "artifact";
+      return appendItem(slice, {
+        kind: "artifact",
+        id: ctx.uuid(),
+        artifactKind,
+        ts: ctx.now()
+      });
+    }
+  }
+}
+function appendItem(slice, item) {
+  return { ...slice, transcript: [...slice.transcript, item] };
+}
+function extractAnswerText2(event) {
+  const data = event.data;
+  if (typeof data?.text === "string" && data.text.length > 0) return data.text;
+  if (typeof data?.answer === "string" && data.answer.length > 0) {
+    return data.answer;
+  }
+  return null;
+}
+function upsertAssistantItem(slice, event, runId, ctx) {
+  const text = extractAnswerText2(event);
+  const existingId = slice.currentAssistantItemId;
+  if (existingId) {
+    if (text === null) return slice;
+    return {
+      ...slice,
+      transcript: slice.transcript.map(
+        (item2) => item2.kind === "assistant" && item2.id === existingId ? { ...item2, text, status: "streaming" } : item2
+      )
+    };
+  }
+  const id = ctx.uuid();
+  const item = {
+    kind: "assistant",
+    id,
+    runId,
+    text: text ?? "",
+    status: "streaming",
+    ts: ctx.now()
+  };
+  return {
+    ...slice,
+    currentAssistantItemId: id,
+    transcript: [...slice.transcript, item]
+  };
+}
+var TOOL_VERB_PREFIX_RE = /^(Starting|Started|Completed|Finished|Failed|Running|Executing)\s+/i;
+function normalizeToolName(raw) {
+  return raw.replace(TOOL_VERB_PREFIX_RE, "").trim();
+}
+function extractToolName(event) {
+  const raw = typeof event.data.tool === "string" && event.data.tool.length > 0 ? event.data.tool : typeof event.data.name === "string" && event.data.name.length > 0 ? event.data.name : event.message;
+  return normalizeToolName(raw);
+}
+function appendToolItem(slice, event, status, ctx) {
+  const name = extractToolName(event);
+  const item = {
+    kind: "tool",
+    id: ctx.uuid(),
+    name,
+    status,
+    message: event.message.length > 0 ? event.message : null,
+    ts: ctx.now()
+  };
+  return appendItem(slice, item);
+}
+function flipOrAppendTool(slice, event, status, ctx) {
+  const name = extractToolName(event);
+  for (let i = slice.transcript.length - 1; i >= 0; i -= 1) {
+    const item = slice.transcript[i];
+    if (item && item.kind === "tool" && item.status === "running" && item.name === name) {
+      const message = event.message.length > 0 ? event.message : item.message;
+      const updated = { ...item, status, message };
+      const next = slice.transcript.slice();
+      next[i] = updated;
+      return { ...slice, transcript: next };
+    }
+  }
+  return appendToolItem(slice, event, status, ctx);
+}
+
+// src/tui/session/types.ts
+var ZERO_USAGE = {
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheCreationTokens: 0,
+  costUsd: 0,
+  lastAgent: null,
+  lastCostUsd: null
+};
+
+// src/tui/session/reducer.ts
+function initialSession(init, ctx) {
+  return {
+    meta: {
+      conversationId: ctx.uuid(),
+      tenantId: init.tenantId,
+      userId: init.userId,
+      mode: init.mode,
+      baseUrl: init.baseUrl,
+      profileName: init.profileName ?? null,
+      debug: init.debug ?? false
+    },
+    transcript: [],
+    pendingApprovals: [],
+    resolvedApprovals: [],
+    currentRunId: null,
+    currentAssistantItemId: null,
+    currentThinkingItemId: null,
+    usageTotals: { ...ZERO_USAGE },
+    warnAgenticTenantMismatch: isAgenticTenantMismatch(
+      init.mode,
+      init.tenantId
+    ),
+    lastSubmittedPrompt: null
+  };
+}
+function reduce(state, action, ctx) {
+  switch (action.kind) {
+    case "BEGIN_TURN": {
+      const item = {
+        kind: "user",
+        id: ctx.uuid(),
+        text: action.prompt,
+        ts: ctx.now()
+      };
+      return {
+        ...state,
+        transcript: [...state.transcript, item],
+        lastSubmittedPrompt: action.prompt,
+        currentAssistantItemId: null,
+        currentThinkingItemId: null,
+        currentRunId: `pending:${ctx.uuid()}`
+      };
+    }
+    case "STREAM_EVENT": {
+      const slice = applyHarnessEvent(
+        {
+          transcript: state.transcript,
+          currentAssistantItemId: state.currentAssistantItemId,
+          currentThinkingItemId: state.currentThinkingItemId,
+          pendingApprovals: state.pendingApprovals,
+          currentRunId: state.currentRunId,
+          usageTotals: state.usageTotals
+        },
+        action.event,
+        action.runId,
+        ctx
+      );
+      return {
+        ...state,
+        transcript: slice.transcript,
+        currentAssistantItemId: slice.currentAssistantItemId,
+        currentThinkingItemId: slice.currentThinkingItemId,
+        pendingApprovals: slice.pendingApprovals,
+        currentRunId: slice.currentRunId,
+        usageTotals: slice.usageTotals
+      };
+    }
+    case "END_TURN":
+      return applyEndTurn(state, action.record, action.failureMessage, ctx);
+    case "SET_MODE": {
+      const tenant = state.meta.tenantId;
+      return {
+        ...state,
+        meta: { ...state.meta, mode: action.mode },
+        warnAgenticTenantMismatch: isAgenticTenantMismatch(
+          action.mode,
+          tenant
+        )
+      };
+    }
+    case "SET_TENANT":
+      return {
+        ...state,
+        meta: { ...state.meta, tenantId: action.tenant },
+        warnAgenticTenantMismatch: isAgenticTenantMismatch(
+          state.meta.mode,
+          action.tenant
+        )
+      };
+    case "SET_USER":
+      return { ...state, meta: { ...state.meta, userId: action.user } };
+    case "RESET_CONVERSATION":
+      return {
+        ...state,
+        meta: { ...state.meta, conversationId: ctx.uuid() },
+        transcript: [],
+        pendingApprovals: [],
+        resolvedApprovals: [],
+        currentRunId: null,
+        currentAssistantItemId: null,
+        currentThinkingItemId: null,
+        usageTotals: { ...ZERO_USAGE },
+        lastSubmittedPrompt: null
+      };
+    case "CLEAR":
+      return {
+        ...state,
+        transcript: [],
+        currentAssistantItemId: null,
+        currentThinkingItemId: null,
+        usageTotals: { ...ZERO_USAGE }
+      };
+    case "LOAD_SESSION":
+      return action.state;
+    case "RECORD_APPROVAL": {
+      const approval = {
+        id: action.approval.id,
+        runId: action.approval.runId,
+        message: action.approval.message,
+        data: action.approval.data,
+        ts: action.approval.ts ?? ctx.now()
+      };
+      return {
+        ...state,
+        pendingApprovals: [...state.pendingApprovals, approval]
+      };
+    }
+    case "RESOLVE_APPROVAL":
+      return {
+        ...state,
+        pendingApprovals: state.pendingApprovals.filter(
+          (a) => a.id !== action.id
+        ),
+        resolvedApprovals: [
+          ...state.resolvedApprovals,
+          { id: action.id, decision: action.decision, ts: ctx.now() }
+        ]
+      };
+  }
+}
+function applyEndTurn(state, record, failureMessage, ctx) {
+  const ts = ctx.now();
+  const assistantId = state.currentAssistantItemId;
+  if (failureMessage !== void 0) {
+    const transcript2 = state.transcript.map(
+      (item) => item.kind === "assistant" && item.id === assistantId ? { ...item, status: "failed" } : item
+    );
+    const systemItem = {
+      kind: "system",
+      id: ctx.uuid(),
+      text: `error: ${failureMessage}`,
+      ts
+    };
+    return {
+      ...state,
+      transcript: [...transcript2, systemItem],
+      currentRunId: null,
+      currentAssistantItemId: null,
+      currentThinkingItemId: null
+    };
+  }
+  if (assistantId === null) {
+    if (record && typeof record.answer === "string" && record.answer.length > 0) {
+      const item = {
+        kind: "assistant",
+        id: ctx.uuid(),
+        runId: state.currentRunId ?? "",
+        text: record.answer,
+        status: "complete",
+        ts
+      };
+      return {
+        ...state,
+        transcript: [...state.transcript, item],
+        currentRunId: null,
+        currentAssistantItemId: null,
+        currentThinkingItemId: null
+      };
+    }
+    const placeholder = {
+      kind: "system",
+      id: ctx.uuid(),
+      text: "(no answer recorded)",
+      ts
+    };
+    return {
+      ...state,
+      transcript: [...state.transcript, placeholder],
+      currentRunId: null,
+      currentAssistantItemId: null,
+      currentThinkingItemId: null
+    };
+  }
+  const transcript = state.transcript.map((item) => {
+    if (item.kind !== "assistant" || item.id !== assistantId) return item;
+    const text = record && typeof record.answer === "string" && record.answer.length > 0 ? record.answer : item.text;
+    return { ...item, text, status: "complete" };
+  });
+  return {
+    ...state,
+    transcript,
+    currentRunId: null,
+    currentAssistantItemId: null,
+    currentThinkingItemId: null
+  };
+}
+
+// src/tui/persistence/paths.ts
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+function defaultMiotChatHome() {
+  return join4(homedir3(), ".miot-chat");
+}
+function sessionsDir(home) {
+  return join4(home, "sessions");
+}
+function sessionFile(home, conversationId) {
+  return join4(sessionsDir(home), `${conversationId}.json`);
+}
+
+// src/tui/useSession.ts
+var DEBUG_ENV = "MIOT_CHAT_TUI_DEBUG";
+function debugEnabled() {
+  return process.env[DEBUG_ENV] === "1";
+}
+function debugLogPath() {
+  return `${defaultMiotChatHome()}/last-run.log`;
+}
+function debugLog(line) {
+  if (!debugEnabled()) return;
+  try {
+    const path = debugLogPath();
+    mkdirSync3(dirname3(path), { recursive: true });
+    appendFileSync(
+      path,
+      `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...line })}
+`
+    );
+  } catch {
+  }
+}
+function useSession(opts) {
+  const [state, dispatch] = useReducer2(
+    (s, a) => reduce(s, a, opts.ctx),
+    null,
+    () => initialSession(opts.initial, opts.ctx)
+  );
+  const stateRef = useRef(state);
+  useEffect2(() => {
+    stateRef.current = state;
+  }, [state]);
+  const abortRef = useRef(null);
+  const submit = useCallback(
+    async (prompt) => {
+      const meta = stateRef.current.meta;
+      const trimmed = prompt.trim();
+      if (trimmed.length === 0) return;
+      debugLog({ event: "submit", prompt, meta });
+      dispatch({ kind: "BEGIN_TURN", prompt });
+      const controller = new AbortController();
+      abortRef.current = controller;
+      let runId;
+      try {
+        const created = await opts.client.runs.create(
+          {
+            message: prompt,
+            tenant_id: meta.tenantId,
+            user_id: meta.userId,
+            mode: meta.mode,
+            conversation_id: meta.conversationId,
+            ...meta.debug ? { debug: true } : {}
+          },
+          { signal: controller.signal }
+        );
+        runId = created.run_id;
+        debugLog({ event: "create.ok", runId });
+      } catch (err) {
+        debugLog({
+          event: "create.err",
+          message: err instanceof Error ? err.message : String(err)
+        });
+        dispatch({
+          kind: "END_TURN",
+          failureMessage: err instanceof Error ? err.message : String(err)
+        });
+        return;
+      }
+      try {
+        for await (const event of opts.client.runs.stream(runId, {
+          signal: controller.signal
+        })) {
+          debugLog({
+            event: "stream.event",
+            runId,
+            type: event.type,
+            seq: event.seq,
+            message: event.message,
+            data: event.data
+          });
+          dispatch({ kind: "STREAM_EVENT", event, runId });
+          if (event.type === "run.completed" || event.type === "run.failed") {
+            break;
+          }
+        }
+        debugLog({ event: "stream.end", runId });
+      } catch (err) {
+        debugLog({
+          event: "stream.err",
+          runId,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        dispatch({
+          kind: "END_TURN",
+          failureMessage: err instanceof Error ? err.message : String(err)
+        });
+        return;
+      }
+      const recordController = new AbortController();
+      const RECORD_TIMEOUT_MS = 8e3;
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        recordController.abort();
+      }, RECORD_TIMEOUT_MS);
+      debugLog({ event: "get.start", runId });
+      try {
+        const record = await opts.client.runs.get(runId, {
+          signal: recordController.signal
+        });
+        debugLog({
+          event: "get.ok",
+          runId,
+          answerLength: record.answer?.length ?? null,
+          status: record.status
+        });
+        dispatch({ kind: "END_TURN", record });
+      } catch (err) {
+        const detail = timedOut ? `run record fetch timed out after ${RECORD_TIMEOUT_MS}ms \u2014 check that GET /runs/${runId} returns promptly` : err instanceof Error ? err.message : String(err);
+        debugLog({ event: "get.err", runId, timedOut, message: detail });
+        dispatch({ kind: "END_TURN", failureMessage: detail });
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    [opts.client]
+  );
+  const abort = useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+  return { state, dispatch, submit, abort };
+}
+
+// src/tui/slash/parse.ts
+function parseSlash2(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const body = trimmed.slice(1);
+  if (body.length === 0) return null;
+  const tokens = body.split(/\s+/);
+  const head = (tokens[0] ?? "").toLowerCase();
+  if (head.length === 0) return null;
+  return { name: head, args: tokens.slice(1) };
+}
+
+// src/tui/slash/registry.ts
+var SlashRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  register(cmd) {
+    this.commands.set(cmd.name, cmd);
+    return this;
+  }
+  has(name) {
+    return this.commands.has(name);
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+  all() {
+    return [...this.commands.values()].sort(
+      (a, b) => a.name.localeCompare(b.name)
+    );
+  }
+  /**
+   * Substring-match across command names AND summaries.
+   * Empty prefix returns all commands.
+   * Matches in the name field are ranked above matches in the summary.
+   */
+  findMatches(prefix) {
+    const q = prefix.toLowerCase();
+    if (q.length === 0) return this.all();
+    const nameHits = [];
+    const summaryHits = [];
+    for (const cmd of this.all()) {
+      if (cmd.name.toLowerCase().includes(q)) nameHits.push(cmd);
+      else if (cmd.summary.toLowerCase().includes(q)) summaryHits.push(cmd);
+    }
+    return [...nameHits, ...summaryHits];
+  }
+  /**
+   * Tab-completion target: returns the unique match's name when there is
+   * exactly one, otherwise null. The palette uses this to decide whether
+   * Tab should auto-complete or just keep the dropdown open.
+   */
+  tabCompletion(prefix) {
+    const matches = this.findMatches(prefix);
+    return matches.length === 1 && matches[0] ? matches[0].name : null;
+  }
+};
+
+// src/tui/slash/handlers/help.ts
+function isHelpCtx(ctx) {
+  return typeof ctx.registry === "object" && ctx.registry !== null && "all" in ctx.registry && typeof ctx.now === "function" && typeof ctx.uuid === "function";
+}
+var helpCommand = {
+  name: "help",
+  summary: "List slash commands",
+  usage: "/help",
+  handle: (_args, ctx) => {
+    if (!isHelpCtx(ctx)) {
+      return { error: "help: registry/now/uuid not bound on SlashContext" };
+    }
+    const lines = ctx.registry.all().map((c) => `  ${c.usage.padEnd(22)} ${c.summary}`);
+    const item = {
+      kind: "system",
+      id: ctx.uuid(),
+      text: ["available commands:", ...lines].join("\n"),
+      ts: ctx.now()
+    };
+    return { output: item };
+  }
+};
+
+// src/tui/slash/handlers/clear.ts
+var clearCommand = {
+  name: "clear",
+  summary: "Clear the transcript",
+  usage: "/clear",
+  handle: () => ({ dispatch: { kind: "CLEAR" } })
+};
+
+// src/tui/slash/handlers/reset.ts
+var resetCommand = {
+  name: "reset",
+  summary: "Start a new conversation",
+  usage: "/reset",
+  handle: () => ({ dispatch: { kind: "RESET_CONVERSATION" } })
+};
+
+// src/tui/slash/handlers/exit.ts
+var exitCommand = {
+  name: "exit",
+  summary: "Quit the chat",
+  usage: "/exit",
+  handle: () => ({ abort: true })
+};
+
+// src/tui/slash/handlers/mode.ts
+var VALID_MODES3 = [
+  "auto",
+  "canned",
+  "meta",
+  "agentic"
+];
+var modeCommand = {
+  name: "mode",
+  summary: "Change the run mode (auto/canned/meta/agentic)",
+  usage: "/mode <auto|canned|meta|agentic>",
+  argSchema: [
+    {
+      name: "mode",
+      required: true,
+      choices: VALID_MODES3
+    }
+  ],
+  handle: (args) => {
+    const value = args[0];
+    if (value === void 0) {
+      return { error: "usage: /mode <auto|canned|meta|agentic>" };
+    }
+    if (!VALID_MODES3.includes(value)) {
+      return { error: `unknown mode: ${value}` };
+    }
+    return { dispatch: { kind: "SET_MODE", mode: value } };
+  }
+};
+
+// src/tui/slash/handlers/tenant.ts
+var tenantCommand = {
+  name: "tenant",
+  summary: "Switch the active tenant id",
+  usage: "/tenant <id>",
+  argSchema: [{ name: "tenant", required: true }],
+  handle: (args) => {
+    const value = args[0];
+    if (value === void 0 || value.length === 0) {
+      return { error: "usage: /tenant <id>" };
+    }
+    return { dispatch: { kind: "SET_TENANT", tenant: value } };
+  }
+};
+
+// src/tui/slash/handlers/user.ts
+var userCommand = {
+  name: "user",
+  summary: "Set the active user id",
+  usage: "/user <id>",
+  argSchema: [{ name: "user", required: true }],
+  handle: (args) => {
+    const value = args[0];
+    if (value === void 0 || value.length === 0) {
+      return { error: "usage: /user <id>" };
+    }
+    return { dispatch: { kind: "SET_USER", user: value } };
+  }
+};
+
+// src/tui/slash/handlers/save.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+function isSaveCtx(ctx) {
+  return typeof ctx.session === "object" && ctx.session !== null && typeof ctx.now === "function" && typeof ctx.uuid === "function";
+}
+var saveCommand = {
+  name: "save",
+  summary: "Write the current transcript to a JSON file",
+  usage: "/save <path>",
+  argSchema: [{ name: "path", required: true }],
+  handle: (args, ctx) => {
+    const path = args.join(" ").trim();
+    if (path.length === 0) {
+      return { error: "usage: /save <path>" };
+    }
+    if (!isSaveCtx(ctx)) {
+      return { error: "save: session/now/uuid not bound on SlashContext" };
+    }
+    const body = JSON.stringify(
+      {
+        conversation_id: ctx.session.meta.conversationId,
+        transcript: ctx.session.transcript
+      },
+      null,
+      2
+    );
+    const write = ctx.writeFile ?? defaultWrite;
+    try {
+      write(path, body);
+    } catch (err) {
+      return {
+        error: `save failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const item = {
+      kind: "system",
+      id: ctx.uuid(),
+      text: `saved transcript to ${path}`,
+      ts: ctx.now()
+    };
+    return { output: item };
+  }
+};
+function defaultWrite(path, body) {
+  writeFileSync5(path, body);
+}
+
+// src/tui/slash/handlers/context.ts
+var contextCommand = {
+  name: "context",
+  summary: "Show session context modal",
+  usage: "/context",
+  handle: () => ({ modal: { kind: "context" } })
+};
+
+// src/tui/slash/handlers/whoami.ts
+function isWhoamiCtx(ctx) {
+  return typeof ctx.session === "object" && ctx.session !== null && typeof ctx.now === "function" && typeof ctx.uuid === "function";
+}
+var whoamiCommand = {
+  name: "whoami",
+  summary: "Print user/tenant/conversation ids",
+  usage: "/whoami",
+  handle: (_args, ctx) => {
+    if (!isWhoamiCtx(ctx)) {
+      return { error: "whoami: session/now/uuid not bound on SlashContext" };
+    }
+    const m = ctx.session.meta;
+    const item = {
+      kind: "system",
+      id: ctx.uuid(),
+      text: `user=${m.userId}  tenant=${m.tenantId}  conv=${m.conversationId}`,
+      ts: ctx.now()
+    };
+    return { output: item };
+  }
+};
+
+// src/tui/slash/handlers/theme.ts
+var themeCommand = {
+  name: "theme",
+  summary: "Pick or set the active color theme",
+  usage: "/theme [name]",
+  handle: (args) => {
+    const name = args[0];
+    if (name && name.length > 0) {
+      return { modal: { kind: "theme", payload: { name } } };
+    }
+    return { modal: { kind: "theme" } };
+  }
+};
+
+// src/tui/slash/handlers/resume.ts
+var resumeCommand = {
+  name: "resume",
+  summary: "Pick a saved session to reload",
+  usage: "/resume",
+  handle: () => ({ modal: { kind: "resume" } })
+};
+
+// src/tui/slash/handlers/export.ts
+import { writeFileSync as writeFileSync6 } from "fs";
+
+// src/tui/persistence/exportMarkdown.ts
+function toMarkdown(state) {
+  const lines = [];
+  const m = state.meta;
+  lines.push(`# miot-chat session ${m.conversationId.slice(0, 8)}`);
+  lines.push("");
+  lines.push(`- conversation_id: \`${m.conversationId}\``);
+  lines.push(`- tenant: \`${m.tenantId}\``);
+  lines.push(`- user: \`${m.userId}\``);
+  lines.push(`- mode: \`${m.mode}\``);
+  lines.push(`- baseUrl: ${m.baseUrl}`);
+  if (m.profileName) lines.push(`- profile: \`${m.profileName}\``);
+  lines.push("");
+  const turns = splitIntoTurns(state.transcript);
+  if (turns.length === 0) {
+    lines.push("_(no turns)_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  turns.forEach((turn, idx) => {
+    lines.push(`## Turn ${idx + 1}`);
+    lines.push("");
+    for (const item of turn) {
+      lines.push(...renderItem(item));
+    }
+    lines.push("");
+  });
+  return lines.join("\n");
+}
+function splitIntoTurns(items) {
+  const turns = [];
+  let current = [];
+  for (const item of items) {
+    if (item.kind === "user") {
+      if (current.length > 0) turns.push(current);
+      current = [item];
+    } else {
+      current.push(item);
+    }
+  }
+  if (current.length > 0) turns.push(current);
+  return turns;
+}
+function renderItem(item) {
+  switch (item.kind) {
+    case "user":
+      return [`**you:** ${item.text}`, ""];
+    case "assistant":
+      return [`**miot${statusSuffix2(item.status)}:** ${item.text}`, ""];
+    case "tool":
+      return [`> tool ${item.name} ${toolGlyph(item.status)}${item.message ? ` \u2014 ${item.message}` : ""}`];
+    case "route":
+      return [`> route: ${item.route}`];
+    case "agent":
+      return [`> agent: ${item.agent}`];
+    case "thinking":
+      return [`> _thinking (${item.agent}):_ ${item.text}`];
+    case "plan":
+      return [`> plan: ${item.message}`];
+    case "freshness":
+      return [`> \u26A0 ${item.message}`];
+    case "artifact":
+      return [`> artifact: ${item.artifactKind}`];
+    case "system":
+      return [`> _${item.text}_`];
+  }
+}
+function statusSuffix2(status) {
+  if (status === "failed") return " (failed)";
+  if (status === "streaming") return " (streaming)";
+  return "";
+}
+function toolGlyph(status) {
+  if (status === "ok") return "\u2713";
+  if (status === "failed") return "\u2717";
+  return "\u2026";
+}
+
+// src/tui/slash/handlers/export.ts
+function isExportCtx(ctx) {
+  return typeof ctx.session === "object" && ctx.session !== null && typeof ctx.now === "function" && typeof ctx.uuid === "function";
+}
+var exportCommand = {
+  name: "export",
+  summary: "Write the transcript as markdown to a file",
+  usage: "/export <path>",
+  argSchema: [{ name: "path", required: true }],
+  handle: (args, ctx) => {
+    const path = args.join(" ").trim();
+    if (path.length === 0) {
+      return { error: "usage: /export <path>" };
+    }
+    if (!isExportCtx(ctx)) {
+      return { error: "export: session/now/uuid not bound on SlashContext" };
+    }
+    const body = toMarkdown(ctx.session);
+    const write = ctx.writeFile ?? defaultWrite2;
+    try {
+      write(path, body);
+    } catch (err) {
+      return {
+        error: `export failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const item = {
+      kind: "system",
+      id: ctx.uuid(),
+      text: `exported transcript to ${path}`,
+      ts: ctx.now()
+    };
+    return { output: item };
+  }
+};
+function defaultWrite2(path, body) {
+  writeFileSync6(path, body);
+}
+
+// src/tui/slash/handlers/runs.ts
+var runsCommand = {
+  name: "runs",
+  summary: "Pick a recent run to replay",
+  usage: "/runs",
+  handle: () => ({ modal: { kind: "runs" } })
+};
+
+// src/tui/slash/handlers/approve.ts
+var VALID_DECISIONS = [
+  "approve",
+  "deny",
+  "later"
+];
+var approveCommand = {
+  name: "approve",
+  summary: "Resolve a pending approval (approve|deny|later) <id>",
+  usage: "/approve <approve|deny|later> <id>",
+  argSchema: [
+    { name: "decision", required: true, choices: VALID_DECISIONS },
+    { name: "id", required: true }
+  ],
+  handle: (args) => {
+    const decision = args[0];
+    const id = args[1];
+    if (decision === void 0 || id === void 0) {
+      return { error: "usage: /approve <approve|deny|later> <id>" };
+    }
+    if (!VALID_DECISIONS.includes(decision)) {
+      return { error: `unknown decision: ${decision}` };
+    }
+    return {
+      dispatch: {
+        kind: "RESOLVE_APPROVAL",
+        id,
+        decision
+      }
+    };
+  }
+};
+
+// src/tui/persistence/store.ts
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  readdirSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { extname, join as join5 } from "path";
+function readSession(home, conversationId) {
+  const path = sessionFile(home, conversationId);
+  if (!existsSync4(path)) return null;
+  const raw = readFileSync5(path, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function listSessions(home) {
+  const dir = sessionsDir(home);
+  if (!existsSync4(dir)) return [];
+  const entries = readdirSync(dir);
+  const summaries = [];
+  for (const name of entries) {
+    if (extname(name) !== ".json") continue;
+    if (name.endsWith(".tmp.json")) continue;
+    const id = name.slice(0, -".json".length);
+    const path = join5(dir, name);
+    let state = null;
+    try {
+      state = JSON.parse(readFileSync5(path, "utf8"));
+    } catch {
+      continue;
+    }
+    const mtime = statSync(path).mtimeMs;
+    summaries.push({
+      id,
+      lastTurn: lastTurnCount(state),
+      lastPrompt: lastUserPrompt(state),
+      mtime
+    });
+  }
+  summaries.sort((a, b) => b.mtime - a.mtime);
+  return summaries;
+}
+function lastTurnCount(state) {
+  if (!state) return 0;
+  return state.transcript.filter((i) => i.kind === "user").length;
+}
+function lastUserPrompt(state) {
+  if (!state) return null;
+  for (let i = state.transcript.length - 1; i >= 0; i -= 1) {
+    const item = state.transcript[i];
+    if (item && item.kind === "user") return item.text;
+  }
+  return null;
+}
+
+// src/tui/App.tsx
+import { Text as Text13 } from "ink";
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function App(props) {
+  const themeResult = useMemo2(
+    () => loadUserTheme(props.config.theme),
+    [props.config.theme]
+  );
+  return /* @__PURE__ */ jsx14(ThemeProvider, { initialTheme: themeResult.theme, children: /* @__PURE__ */ jsx14(AppInner, { ...props, themeWarning: themeResult.warning }) });
+}
+function AppInner(props) {
+  const home = props.home ?? defaultMiotChatHome();
+  const now = props.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const uuid = props.uuid ?? (() => randomUUID3());
+  const ctx = useMemo2(() => ({ now, uuid }), [now, uuid]);
+  const session = useSession({
+    initial: {
+      tenantId: props.config.tenantId,
+      userId: props.config.userId,
+      mode: props.config.mode,
+      baseUrl: props.config.baseUrl,
+      profileName: props.config.profileName,
+      debug: props.config.debug
+    },
+    ctx,
+    client: props.client
+  });
+  const { setTheme } = useTheme();
+  const [extraItems, setExtraItems] = useState7([]);
+  const [modal, setModalState] = useState7({ spec: null });
+  const registry = useMemo2(() => {
+    const reg = new SlashRegistry();
+    reg.register(helpCommand).register(clearCommand).register(resetCommand).register(exitCommand).register(modeCommand).register(tenantCommand).register(userCommand).register(saveCommand).register(contextCommand).register(whoamiCommand).register(themeCommand).register(resumeCommand).register(exportCommand).register(runsCommand).register(approveCommand);
+    return reg;
+  }, []);
+  const appendSystem = useCallback2(
+    (text) => {
+      setExtraItems((prev) => [
+        ...prev,
+        { kind: "system", id: uuid(), text, ts: now() }
+      ]);
+    },
+    [now, uuid]
+  );
+  const dispatchSlash = useCallback2(
+    async (line) => {
+      const parsed = parseSlash2(line);
+      if (!parsed) return;
+      const cmd = registry.get(parsed.name);
+      if (!cmd) {
+        appendSystem(`unknown command: /${parsed.name}`);
+        return;
+      }
+      const slashCtx = {
+        registry,
+        session: session.state,
+        now,
+        uuid,
+        home,
+        client: props.client
+      };
+      try {
+        const result = await cmd.handle(parsed.args, slashCtx);
+        if (result.error) appendSystem(result.error);
+        if (result.dispatch) session.dispatch(result.dispatch);
+        if (result.output) {
+          setExtraItems((prev) => [...prev, result.output]);
+        }
+        if (result.modal) setModalState({ spec: result.modal });
+        if (result.abort && props.onExit) props.onExit();
+      } catch (err) {
+        appendSystem(
+          `error in /${parsed.name}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    },
+    [
+      registry,
+      session,
+      now,
+      uuid,
+      home,
+      props.client,
+      props.onExit,
+      appendSystem
+    ]
+  );
+  const handleSubmit = useCallback2(
+    (text) => {
+      if (text.trim().startsWith("/")) {
+        void dispatchSlash(text);
+        return;
+      }
+      void session.submit(text);
+    },
+    [dispatchSlash, session]
+  );
+  const closeModal = useCallback2(
+    () => setModalState({ spec: null }),
+    []
+  );
+  const allItems = useMemo2(
+    () => [...session.state.transcript, ...extraItems],
+    [session.state.transcript, extraItems]
+  );
+  const modalSpec = modal.spec;
+  const editorActive = modalSpec === null;
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+    props.themeWarning ? /* @__PURE__ */ jsx14(Box12, { paddingX: 1, children: /* @__PURE__ */ jsx14(SystemNote, { text: `theme: ${props.themeWarning}` }) }) : null,
+    /* @__PURE__ */ jsx14(
+      Transcript,
+      {
+        items: allItems,
+        isStreaming: isStreaming(session.state)
+      }
+    ),
+    modalSpec?.kind === "context" ? /* @__PURE__ */ jsx14(
+      ContextModal,
+      {
+        session: session.state,
+        lastRunId: session.state.currentRunId,
+        onClose: closeModal
+      }
+    ) : null,
+    modalSpec?.kind === "resume" ? /* @__PURE__ */ jsx14(
+      ResumePicker,
+      {
+        summaries: listSessions(home),
+        onSelect: (id) => {
+          const loaded = readSession(home, id);
+          if (loaded) session.dispatch({ kind: "LOAD_SESSION", state: loaded });
+          else appendSystem(`could not read session ${id}`);
+          closeModal();
+        },
+        onCancel: closeModal
+      }
+    ) : null,
+    modalSpec?.kind === "theme" ? /* @__PURE__ */ jsx14(
+      ThemePicker,
+      {
+        initialName: typeof modalSpec.payload?.name === "string" ? modalSpec.payload.name : void 0,
+        onSelect: (name) => {
+          const next = BUILTIN_THEMES[name];
+          if (next) {
+            setTheme(next);
+            appendSystem(`theme: ${name}`);
+          }
+          closeModal();
+        },
+        onCancel: closeModal
+      }
+    ) : null,
+    modalSpec?.kind === "approval" && isApprovalsUiEnabled() && session.state.pendingApprovals.length > 0 ? /* @__PURE__ */ jsx14(
+      ApprovalModal,
+      {
+        approval: session.state.pendingApprovals[0],
+        onResolve: (decision, id) => {
+          session.dispatch({ kind: "RESOLVE_APPROVAL", id, decision });
+          closeModal();
+        }
+      }
+    ) : null,
+    modalSpec?.kind === "runs" ? /* @__PURE__ */ jsx14(
+      RunsPickerWrapped,
+      {
+        state: session.state,
+        onSelect: (runId) => {
+          appendSystem(`replay run ${runId} \u2014 not yet implemented`);
+          closeModal();
+        },
+        onCancel: closeModal
+      }
+    ) : null,
+    /* @__PURE__ */ jsx14(
+      Header,
+      {
+        meta: session.state.meta,
+        streaming: isStreaming(session.state),
+        pendingApprovals: pendingApprovalCount(session.state),
+        turns: turnCount(session.state),
+        approxTokens: approxTokenCount(session.state),
+        contextPercent: contextPercent(session.state),
+        usageTotals: session.state.usageTotals
+      }
+    ),
+    /* @__PURE__ */ jsx14(Editor, { onSubmit: handleSubmit, isFocused: editorActive })
+  ] });
+}
+function RunsPickerWrapped(props) {
+  const runs = summarizeRuns(props.state);
+  return /* @__PURE__ */ jsx14(RunsPicker, { runs, onSelect: props.onSelect, onCancel: props.onCancel });
+}
+function SystemNote(props) {
+  return /* @__PURE__ */ jsx14(Box12, { children: /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: props.text }) });
+}
+
+// src/tui/runTui.ts
+function runTui(opts) {
+  const instance = render(
+    createElement(App, {
+      config: opts.config,
+      client: opts.client,
+      onExit: () => instance.unmount()
+    })
+  );
+  return {
+    waitUntilExit: async () => {
+      await instance.waitUntilExit();
+    },
+    unmount: () => instance.unmount()
+  };
+}
+
+// src/commands/resume.ts
+function registerResumeCommand(program2) {
+  program2.command("resume").description(
+    "Resume the most recent session. In a TTY launches the TUI (use /resume inside to pick); piped stdin reuses the last conversation_id with the headless REPL."
+  ).action(async () => {
+    const flags = program2.opts();
+    const config = resolveConfig({ flags });
+    const client = createMiotHarnessClient2({
+      baseUrl: config.harnessBaseUrl,
+      token: config.token
+    });
+    if (shouldUseTui(process.env, process.stdin, process.stdout)) {
+      const handle = runTui({ config, client });
+      await handle.waitUntilExit();
+      process.exit(0);
+    }
+    const color = {
+      noColor: Boolean(process.env.NO_COLOR),
+      isTTY: process.stdout.isTTY
+    };
+    const conversationId = readLastConversation();
+    if (conversationId === null) {
+      process.stderr.write(
+        `${red("no saved conversation found at ~/.miot-chat/last-conversation", color)}
+`
+      );
+      process.exit(1);
+    }
+    process.stdout.write(
+      `${dim(`resuming conversation: ${conversationId}`, color)}
+`
+    );
+    const code = await runRepl({ config, client, conversationId });
+    process.exit(code);
+  });
+}
+
+// src/commands/runs.ts
+import {
+  MiotHarnessApiError as MiotHarnessApiError3,
+  createMiotHarnessClient as createMiotHarnessClient3
+} from "@microboxlabs/miot-harness-client";
+function registerRunsCommand(program2) {
+  program2.command("runs <run_id>").description("Offline replay of a completed run: GET /runs/{id} and render all events.").action(async (runId) => {
+    const flags = program2.opts();
+    const config = resolveConfig({ flags });
+    const color = {
+      noColor: Boolean(process.env.NO_COLOR),
+      isTTY: process.stdout.isTTY
+    };
+    const client = createMiotHarnessClient3({
+      baseUrl: config.harnessBaseUrl,
+      token: config.token
+    });
+    try {
+      const record = await client.runs.get(runId);
+      process.stdout.write(
+        `${dim(`run ${runId} \u2014 status: ${record.status} \u2014 events: ${record.events.length}`, color)}
+`
+      );
+      let state = initialState(color);
+      for (const event of record.events) {
+        const r = renderEvent(state, event);
+        state = r.state;
+        if (r.output.length > 0) process.stdout.write(r.output);
+      }
+      const cleared = clearStatus(state);
+      if (cleared.output.length > 0) process.stdout.write(cleared.output);
+      const final = renderAuthoritativeAnswer(cleared.state, record.answer);
+      process.stdout.write(final.output);
+      process.exit(record.status === "failed" ? 1 : 0);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`${red(`error: ${msg}`, color)}
+`);
+      process.exit(e instanceof MiotHarnessApiError3 ? 1 : 2);
+    }
+  });
+}
+
+// src/cli.ts
+import { createMiotHarnessClient as createMiotHarnessClient4 } from "@microboxlabs/miot-harness-client";
+
+// src/runMiotChat.ts
+function shouldUseTui(env, stdin, stdout) {
+  if (env.MIOT_CHAT_NO_TUI === "1") return false;
+  return Boolean(stdin.isTTY && stdout.isTTY);
+}
+async function runMiotChat(opts) {
+  const env = opts.env ?? process.env;
+  const stdin = opts.stdin ?? process.stdin;
+  const stdout = opts.stdout ?? process.stdout;
+  if (shouldUseTui(env, stdin, stdout)) {
+    const handle = runTui({ config: opts.config, client: opts.client });
+    await handle.waitUntilExit();
+    return 0;
+  }
+  return runRepl({
+    config: opts.config,
+    client: opts.client,
+    conversationId: opts.conversationId
+  });
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("miot-chat").description(
+  "Copilot-style agentic chat CLI for miot-harness (SSE streaming)."
+).version(version).option("--base-url <url>", "Harness base URL (or MIOT_CHAT_BASE_URL env)").option("--token <token>", "Auth bearer token (or MIOT_CHAT_TOKEN env)").option("--tenant <id>", "Tenant ID (or MIOT_CHAT_TENANT_ID env)").option("--user <id>", "User ID (or MIOT_CHAT_USER_ID env)").option(
+  "--org <slug>",
+  "Organization slug; routes runs through the quarkus harness proxy (or MIOT_CHAT_ORG env)"
+).option(
+  "--mode <mode>",
+  "Dispatch mode: auto | canned | meta | agentic (or MIOT_CHAT_MODE env)"
+).option(
+  "--profile <name>",
+  "Named profile from ~/.miot-chat/config.json (or MIOT_CHAT_PROFILE env)"
+).option(
+  "--debug",
+  "Stream full tool inputs and truncated outputs (requires the harness to allow-list this tenant for debug; or MIOT_CHAT_DEBUG=1)"
+).action(async () => {
+  const flags = program.opts();
+  const config = resolveConfig({ flags });
+  const client = createMiotHarnessClient4({
+    baseUrl: config.harnessBaseUrl,
+    token: config.token
+  });
+  const code = await runMiotChat({ config, client });
+  process.exit(code);
+});
+registerAskCommand(program);
+registerLoginCommand(program);
+registerResumeCommand(program);
+registerRunsCommand(program);
+program.parseAsync().catch((err) => {
+  process.stderr.write(
+    `${err instanceof Error ? err.message : String(err)}
+`
+  );
+  process.exit(1);
+});
+export {
+  shouldUseTui
+};