@stjbrown/agent-knowledge 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/tui-74FJW5Y4.js

@@ -0,0 +1,1519 @@
+#!/usr/bin/env node
+import { createRequire as __janetCreateRequire } from "node:module";
+const require = __janetCreateRequire(import.meta.url);
+import {
+  GREETING,
+  NATIVE_PROVIDER_DEFINITIONS,
+  availableModels,
+  bootJanet,
+  completeOnboarding,
+  discoverAvailableModels,
+  formatObservabilityStatus,
+  getAuthStorage,
+  groupModelsByProvider,
+  loadSettings,
+  messageText,
+  normalizeModelSelection,
+  rememberModel,
+  rememberObservability,
+  resolveObservabilityConfig,
+  safeObservabilityEndpoint
+} from "./chunk-JZ3GYPHM.js";
+
+// src/tui/index.ts
+import {
+  Container,
+  Editor,
+  Loader,
+  Markdown,
+  ProcessTerminal,
+  SelectList,
+  Spacer,
+  TUI,
+  Text,
+  matchesKey as matchesKey2
+} from "@earendil-works/pi-tui";
+
+// src/memory/compact.ts
+async function compactConversation({
+  memory,
+  agent,
+  threadId,
+  resourceId,
+  requestContext
+}) {
+  const om = await memory.omEngine;
+  if (!om) {
+    throw new Error("Observational Memory is unavailable for this storage.");
+  }
+  await om.waitForBuffering(threadId, resourceId);
+  const before = await om.getStatus({ threadId, resourceId });
+  let buffered = false;
+  if (before.pendingTokens > 0) {
+    const result = await om.buffer({
+      threadId,
+      resourceId,
+      requestContext,
+      agent,
+      pendingTokens: before.pendingTokens,
+      record: before.record,
+      skipMinimumTokenCheck: true
+    });
+    buffered = result.buffered;
+  }
+  await om.waitForBuffering(threadId, resourceId);
+  const activation = await om.activate({
+    threadId,
+    resourceId,
+    checkThreshold: false
+  });
+  const afterActivation = await om.getStatus({ threadId, resourceId });
+  let reflected = false;
+  let record = activation.record;
+  if (afterActivation.shouldReflect) {
+    const reflection = await om.reflect(
+      threadId,
+      resourceId,
+      void 0,
+      requestContext
+    );
+    reflected = reflection.reflected;
+    record = reflection.record;
+  }
+  const after = await om.getStatus({ threadId, resourceId });
+  return {
+    pendingTokensBefore: before.pendingTokens,
+    pendingTokensAfter: after.pendingTokens,
+    observationTokens: record.observationTokenCount,
+    buffered,
+    activated: activation.activated,
+    reflected
+  };
+}
+
+// src/tui/activity.ts
+var WORKSPACE_READ = /* @__PURE__ */ new Set([
+  "mastra_workspace_file_stat",
+  "mastra_workspace_grep",
+  "mastra_workspace_lsp_inspect",
+  "mastra_workspace_list_files",
+  "mastra_workspace_read_file",
+  "mastra_workspace_search"
+]);
+var WORKSPACE_WRITE = /* @__PURE__ */ new Set([
+  "mastra_workspace_ast_edit",
+  "mastra_workspace_delete",
+  "mastra_workspace_edit_file",
+  "mastra_workspace_index",
+  "mastra_workspace_mkdir",
+  "mastra_workspace_write_file"
+]);
+var WORKSPACE_EXECUTE = /* @__PURE__ */ new Set([
+  "mastra_workspace_execute_command",
+  "mastra_workspace_get_process_output",
+  "mastra_workspace_kill_process"
+]);
+var PDF_READ = /* @__PURE__ */ new Set(["janet_read_pdf", "janet_read_pdf_chunk"]);
+var WEB_READ = /* @__PURE__ */ new Set(["janet_web_fetch", "janet_web_fetch_chunk"]);
+function toolActivityLabel(toolName) {
+  if (toolName === "skill" || toolName === "skill_read" || toolName === "skill_search") {
+    return "Janet is reading the playbook\u2026";
+  }
+  if (PDF_READ.has(toolName)) return "Janet is reading the document\u2026";
+  if (WEB_READ.has(toolName)) return "Janet is reading the page\u2026";
+  if (WORKSPACE_READ.has(toolName)) return "Janet is checking the workspace\u2026";
+  if (WORKSPACE_WRITE.has(toolName)) return "Janet is updating the bundle\u2026";
+  if (WORKSPACE_EXECUTE.has(toolName) || toolName.includes("shell")) {
+    return "Janet is running a check\u2026";
+  }
+  return "Janet is working\u2026";
+}
+function toolErrorLabel(result) {
+  const detail = String(result);
+  const readRequired = detail.match(
+    /File "([^"]+)" (?:has not been read|was modified since last read)/
+  );
+  if (readRequired) {
+    return `Update paused: Janet needs to re-read "${readRequired[1]}" first.`;
+  }
+  return `Tool error: ${detail.slice(0, 140)}`;
+}
+
+// src/tui/interrupt.ts
+function createInterruptController(actions, options = {}) {
+  const doublePressMs = options.doublePressMs ?? 800;
+  const now = options.now ?? Date.now;
+  let lastCtrlC;
+  const cancelRun = () => {
+    if (!actions.isRunning()) return "ignored";
+    actions.abortRun();
+    actions.notify("cancelled");
+    return "cancelled";
+  };
+  return {
+    handleCtrlC() {
+      const pressedAt = now();
+      if (lastCtrlC !== void 0 && pressedAt - lastCtrlC < doublePressMs) {
+        actions.notify("exit");
+        actions.exit();
+        return "exit";
+      }
+      lastCtrlC = pressedAt;
+      const cancelled = cancelRun();
+      if (cancelled !== "ignored") return cancelled;
+      if (actions.hasInput()) {
+        actions.clearInput();
+        actions.notify("cleared");
+        return "cleared";
+      }
+      actions.notify("exit-hint");
+      return "exit-hint";
+    },
+    handleEscape() {
+      return cancelRun();
+    }
+  };
+}
+
+// src/tui/multi-select.ts
+import {
+  getKeybindings,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+var MultiSelectList = class {
+  constructor(items, maxVisible, theme, initiallySelected = []) {
+    this.items = items;
+    this.maxVisible = maxVisible;
+    this.theme = theme;
+    this.selectedValues = new Set(initiallySelected);
+  }
+  items;
+  maxVisible;
+  theme;
+  selectedIndex = 0;
+  selectedValues;
+  onConfirm;
+  onCancel;
+  setSelectedIndex(index) {
+    this.selectedIndex = Math.max(0, Math.min(index, this.items.length - 1));
+  }
+  getSelectedItems() {
+    return this.items.filter((item) => this.selectedValues.has(item.value));
+  }
+  invalidate() {
+  }
+  render(width) {
+    if (!this.items.length) {
+      return [this.theme.noMatch("  No options")];
+    }
+    const startIndex = Math.max(
+      0,
+      Math.min(
+        this.selectedIndex - Math.floor(this.maxVisible / 2),
+        this.items.length - this.maxVisible
+      )
+    );
+    const endIndex = Math.min(
+      startIndex + Math.max(1, this.maxVisible),
+      this.items.length
+    );
+    const lines = this.items.slice(startIndex, endIndex).map(
+      (item, offset) => this.renderItem(item, startIndex + offset === this.selectedIndex, width)
+    );
+    if (startIndex > 0 || endIndex < this.items.length) {
+      lines.push(
+        this.theme.scrollInfo(
+          truncateToWidth(
+            `  (${this.selectedIndex + 1}/${this.items.length})`,
+            Math.max(1, width - 2),
+            ""
+          )
+        )
+      );
+    }
+    return lines;
+  }
+  handleInput(keyData) {
+    const keybindings = getKeybindings();
+    if (!this.items.length) {
+      if (keybindings.matches(keyData, "tui.select.cancel")) this.onCancel?.();
+      return;
+    }
+    if (keybindings.matches(keyData, "tui.select.up")) {
+      this.selectedIndex = this.selectedIndex === 0 ? this.items.length - 1 : this.selectedIndex - 1;
+    } else if (keybindings.matches(keyData, "tui.select.down")) {
+      this.selectedIndex = this.selectedIndex === this.items.length - 1 ? 0 : this.selectedIndex + 1;
+    } else if (keybindings.matches(keyData, "tui.select.pageUp")) {
+      this.selectedIndex = Math.max(0, this.selectedIndex - this.maxVisible);
+    } else if (keybindings.matches(keyData, "tui.select.pageDown")) {
+      this.selectedIndex = Math.min(
+        this.items.length - 1,
+        this.selectedIndex + this.maxVisible
+      );
+    } else if (matchesKey(keyData, "space")) {
+      const item = this.items[this.selectedIndex];
+      if (this.selectedValues.has(item.value)) {
+        this.selectedValues.delete(item.value);
+      } else {
+        this.selectedValues.add(item.value);
+      }
+    } else if (keybindings.matches(keyData, "tui.select.confirm")) {
+      this.onConfirm?.(this.getSelectedItems());
+    } else if (keybindings.matches(keyData, "tui.select.cancel")) {
+      this.onCancel?.();
+    }
+  }
+  renderItem(item, isActive, width) {
+    const checked = this.selectedValues.has(item.value);
+    const prefix = isActive ? "\u2192 " : "  ";
+    const checkbox = checked ? "[x]" : "[ ]";
+    const maxWidth = Math.max(1, width - 2);
+    const primary = truncateToWidth(
+      `${prefix}${checkbox} ${item.label || item.value}`,
+      maxWidth,
+      ""
+    );
+    let plain = primary;
+    if (item.description && width > 40) {
+      const remaining = maxWidth - visibleWidth(primary) - 2;
+      if (remaining > 10) {
+        plain += `  ${truncateToWidth(
+          item.description.replace(/[\r\n]+/g, " ").trim(),
+          remaining,
+          ""
+        )}`;
+      }
+    }
+    if (isActive) return this.theme.selectedText(plain);
+    if (!checked) return plain;
+    const markStart = prefix.length;
+    return plain.slice(0, markStart) + this.theme.selectedPrefix(checkbox) + plain.slice(markStart + checkbox.length);
+  }
+};
+
+// src/tui/thread.ts
+async function clearConversation(thread) {
+  const previousThreadId = thread.getId();
+  const created = await thread.create({ title: "Janet conversation" });
+  return { previousThreadId, threadId: created.id };
+}
+
+// src/tui/traces.ts
+function duration(span) {
+  if (!span.endedAt) return "running";
+  const elapsed = Math.max(0, span.endedAt.getTime() - span.startedAt.getTime());
+  return elapsed >= 1e3 ? `${(elapsed / 1e3).toFixed(1)}s` : `${elapsed}ms`;
+}
+function traceStatus(span) {
+  if (span.error) return "error";
+  return span.endedAt ? "ok" : "running";
+}
+function formatTraceTree(spans) {
+  const byParent = /* @__PURE__ */ new Map();
+  const ids = new Set(spans.map((span) => span.spanId));
+  for (const span of spans) {
+    const parent = span.parentSpanId && ids.has(span.parentSpanId) ? span.parentSpanId : null;
+    const children = byParent.get(parent) ?? [];
+    children.push(span);
+    byParent.set(parent, children);
+  }
+  for (const children of byParent.values()) {
+    children.sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
+  }
+  const lines = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (span, depth) => {
+    if (visited.has(span.spanId)) return;
+    visited.add(span.spanId);
+    const status = traceStatus(span);
+    const marker = status === "error" ? "\u2717" : status === "running" ? "\u2026" : "\u2713";
+    lines.push(
+      `${"  ".repeat(depth)}${marker} ${span.name} \xB7 ${span.spanType} \xB7 ${duration(span)}`
+    );
+    for (const child of byParent.get(span.spanId) ?? []) visit(child, depth + 1);
+  };
+  for (const root of byParent.get(null) ?? []) visit(root, 0);
+  return lines;
+}
+
+// src/tui/theme.ts
+import chalk from "chalk";
+var c = {
+  accent: chalk.cyan,
+  accentBold: chalk.cyan.bold,
+  dim: chalk.dim,
+  user: chalk.green,
+  error: chalk.red,
+  warn: chalk.yellow,
+  bold: chalk.bold,
+  italic: chalk.italic
+};
+var editorTheme = {
+  borderColor: (s) => chalk.cyan(s),
+  selectList: {
+    selectedPrefix: (s) => chalk.cyan(s),
+    selectedText: (s) => chalk.cyan.bold(s),
+    description: (s) => chalk.dim(s),
+    scrollInfo: (s) => chalk.dim(s),
+    noMatch: (s) => chalk.dim(s)
+  }
+};
+var markdownTheme = {
+  heading: (s) => chalk.cyan.bold(s),
+  link: (s) => chalk.cyan.underline(s),
+  linkUrl: (s) => chalk.dim(s),
+  code: (s) => chalk.yellow(s),
+  codeBlock: (s) => chalk.yellow(s),
+  codeBlockBorder: (s) => chalk.dim(s),
+  quote: (s) => chalk.italic(s),
+  quoteBorder: (s) => chalk.dim(s),
+  hr: (s) => chalk.dim(s),
+  listBullet: (s) => chalk.cyan(s),
+  bold: (s) => chalk.bold(s),
+  italic: (s) => chalk.italic(s),
+  strikethrough: (s) => chalk.strikethrough(s),
+  underline: (s) => chalk.underline(s)
+};
+
+// src/tui/index.ts
+var OAUTH_PROVIDERS = ["anthropic", "openai-codex"];
+var HELP_TEXT = `Commands:
+  /models                Pick one or more providers, then a model
+  /model [provider/id]   Open the picker, or switch directly by id
+  /providers             Browse provider status and setup
+  /login <provider> [mode]
+                         Log in; OpenAI mode is browser or device
+  /logout <provider>     Remove stored credentials for a provider
+  /auth                  Show which providers are authenticated
+  /observability         Configure opt-in tracing
+  /traces                Browse recent local traces
+  /compact               Flush this conversation into Observational Memory
+  /clear                 Start a blank conversation (keeps the old thread)
+  /cancel                Cancel the active run
+  /help                  This help
+  /quit                  Exit (double Ctrl+C also works)
+
+While Janet is working, Esc or Ctrl+C cancels the active run.
+Anything else is a message to Janet.`;
+function shortTokens(tokens) {
+  if (tokens < 1e3) return String(Math.max(0, Math.round(tokens)));
+  const thousands = tokens / 1e3;
+  return `${thousands >= 10 ? Math.round(thousands) : thousands.toFixed(1)}k`;
+}
+function resolveAnswer(q, text) {
+  if (!q.options?.length) return text;
+  const opts = q.options;
+  const pick = (token) => {
+    const t = token.trim();
+    if (!t) return void 0;
+    const n = Number(t);
+    if (Number.isInteger(n) && n >= 1 && n <= opts.length) return opts[n - 1].label;
+    const exact = opts.find((o) => o.label.toLowerCase() === t.toLowerCase());
+    if (exact) return exact.label;
+    return opts.find((o) => o.label.toLowerCase().startsWith(t.toLowerCase()))?.label;
+  };
+  if (q.multi) {
+    const picks = text.split(",").map(pick);
+    return picks.some((p) => p === void 0) ? void 0 : picks;
+  }
+  return pick(text);
+}
+async function runTui(opts) {
+  const { controller, session, paths, herdrDetach, observability } = await bootJanet({
+    ...opts,
+    interactive: true
+  });
+  const persistedModel = process.env["JANET_MODEL"] || loadSettings().defaultModelId;
+  const presetModel = persistedModel ? normalizeModelSelection(persistedModel, availableModels()) : void 0;
+  if (!session.model.hasSelection() && presetModel) {
+    await session.model.switch({ modelId: presetModel });
+  }
+  const terminal = new ProcessTerminal();
+  const ui = new TUI(terminal);
+  const chat = new Container();
+  const status = new Text("", 1, 0);
+  const editor = new Editor(ui, editorTheme);
+  const loader = new Loader(ui, c.accent, c.dim, "Janet is thinking\u2026");
+  ui.addChild(chat);
+  ui.addChild(new Spacer(1));
+  ui.addChild(editor);
+  ui.addChild(status);
+  let running = false;
+  let loaderMounted = false;
+  let pendingApproval = null;
+  let pendingQuestion = null;
+  let pendingInput = null;
+  let activeSelect = null;
+  let active = null;
+  let cancelRequested = false;
+  let modelPickerLoading = false;
+  let compacting = false;
+  let omWindows = null;
+  let omActivity = null;
+  const activeTools = /* @__PURE__ */ new Map();
+  const updateStatus = () => {
+    const model = session.model.hasSelection() ? session.model.get() : "no model \u2014 /model <id>";
+    const tracing = observability.status.enabled ? c.dim(`  \xB7  trace:${observability.status.capture}`) : "";
+    const memory = omWindows ? c.dim(
+      `  \xB7  mem:${shortTokens(
+        omWindows.active.messages.tokens + omWindows.active.observations.tokens
+      )}/${shortTokens(
+        omWindows.active.messages.threshold + omWindows.active.observations.threshold
+      )}`
+    ) : "";
+    const state = pendingInput ? "enter the requested value" : compacting ? "compacting memory" : omActivity ? `${omActivity} memory` : pendingQuestion || activeSelect ? "answer Janet's question" : pendingApproval ? "awaiting approval" : cancelRequested ? "cancelling" : running ? "working \xB7 Esc/Ctrl+C cancels" : "idle";
+    status.setText(
+      c.dim(`${paths.projectPath}  \xB7  `) + c.accent(model) + c.dim(`  \xB7  ${state}`) + memory + tracing
+    );
+    ui.requestRender();
+  };
+  const appendToChat = (comp) => {
+    if (loaderMounted) chat.removeChild(loader);
+    if (activeSelect) chat.removeChild(activeSelect);
+    chat.addChild(comp);
+    if (activeSelect) chat.addChild(activeSelect);
+    if (loaderMounted) chat.addChild(loader);
+    ui.requestRender();
+  };
+  const addLine = (text) => appendToChat(new Text(text, 1, 0));
+  const setLoader = (on) => {
+    if (on && !loaderMounted) {
+      chat.addChild(loader);
+      loader.start();
+      loaderMounted = true;
+    } else if (!on && loaderMounted) {
+      loader.stop();
+      chat.removeChild(loader);
+      loaderMounted = false;
+    }
+    ui.requestRender();
+  };
+  const closeSegment = () => {
+    if (active) {
+      active.committedLen = active.lastText.length;
+      active.comp = null;
+    }
+  };
+  const answerQuestion = (resumeData, echo) => {
+    if (activeSelect) {
+      chat.removeChild(activeSelect);
+      activeSelect = null;
+    }
+    const q = pendingQuestion;
+    pendingQuestion = null;
+    ui.setFocus(editor);
+    addLine(c.user(`\u276F ${echo}`));
+    setLoader(true);
+    updateStatus();
+    if (q) void session.respondToToolSuspension({ toolCallId: q.toolCallId, resumeData });
+  };
+  const onEvent = (event) => {
+    switch (event.type) {
+      case "agent_start":
+        running = true;
+        cancelRequested = false;
+        active = null;
+        activeTools.clear();
+        loader.setMessage("Janet is thinking\u2026");
+        setLoader(true);
+        updateStatus();
+        break;
+      case "message_update":
+      case "message_end": {
+        if (event.message.role !== "assistant") break;
+        const text = messageText(event.message);
+        if (!text) break;
+        if (!active || active.id !== event.message.id) {
+          active = { id: event.message.id, committedLen: 0, comp: null, lastText: "" };
+        }
+        active.lastText = text;
+        const tail = text.slice(active.committedLen);
+        if (!tail) break;
+        if (!active.comp) {
+          active.comp = new Markdown(tail, 1, 0, markdownTheme);
+          appendToChat(active.comp);
+        } else {
+          active.comp.setText(tail);
+          ui.requestRender();
+        }
+        break;
+      }
+      case "tool_start":
+        closeSegment();
+        if (event.toolName !== "ask_user") {
+          activeTools.set(event.toolCallId, event.toolName);
+          loader.setMessage(toolActivityLabel(event.toolName));
+        }
+        break;
+      case "tool_end":
+        activeTools.delete(event.toolCallId);
+        loader.setMessage(
+          activeTools.size ? toolActivityLabel(Array.from(activeTools.values()).at(-1)) : "Janet is thinking\u2026"
+        );
+        if (event.isError) {
+          closeSegment();
+          addLine(c.warn(`  ${toolErrorLabel(event.result)}`));
+        }
+        break;
+      case "tool_suspended": {
+        closeSegment();
+        activeTools.delete(event.toolCallId);
+        setLoader(false);
+        const payload = event.suspendPayload;
+        const question = payload?.question ?? `Janet needs input for ${event.toolName}.`;
+        const options = payload?.options;
+        const multi = payload?.selectionMode === "multi_select";
+        addLine(c.accentBold(`  Janet asks: ${question}`));
+        if (options?.length && !multi) {
+          const items = options.map((o) => ({
+            value: o.label,
+            label: o.label,
+            ...o.description ? { description: o.description } : {}
+          }));
+          const select = new SelectList(items, Math.min(items.length, 8), editorTheme.selectList);
+          select.onSelect = (item) => answerQuestion(item.value, item.label);
+          select.onCancel = () => {
+            closeActiveSelect(select);
+            addLine(c.dim("     Picker closed. Type your answer instead."));
+            updateStatus();
+          };
+          activeSelect = select;
+          pendingQuestion = { toolCallId: event.toolCallId, options, multi: false };
+          chat.addChild(select);
+          addLine(c.dim("     Use \u2191/\u2193 and Enter \xB7 Esc to close."));
+          ui.setFocus(select);
+        } else {
+          pendingQuestion = { toolCallId: event.toolCallId, options, multi };
+          if (options?.length) {
+            options.forEach(
+              (o, i) => addLine(c.accent(`     ${i + 1}. `) + o.label + (o.description ? c.dim(` \u2014 ${o.description}`) : ""))
+            );
+            addLine(c.dim("     Reply with numbers or labels, then press Enter."));
+          } else {
+            addLine(c.dim("     Type your answer, then press Enter."));
+          }
+        }
+        updateStatus();
+        break;
+      }
+      case "tool_approval_required":
+        closeSegment();
+        activeTools.delete(event.toolCallId);
+        pendingApproval = { toolCallId: event.toolCallId, toolName: event.toolName };
+        addLine(
+          c.warn(`  Janet wants to run ${c.bold(event.toolName)}.`) + c.dim("  y = yes \xB7 n = no \xB7 a = always allow this kind")
+        );
+        updateStatus();
+        break;
+      case "error": {
+        closeSegment();
+        const err = event.error;
+        addLine(
+          c.error(`  Error: ${err?.message || "unknown"}${err?.responseBody ? ` \u2014 ${err.responseBody.slice(0, 200)}` : ""}`)
+        );
+        break;
+      }
+      case "model_changed":
+        updateStatus();
+        break;
+      case "om_status":
+        omWindows = event.windows;
+        updateStatus();
+        break;
+      case "om_buffering_start":
+        omActivity = event.operationType === "reflection" ? "reflecting" : "observing";
+        updateStatus();
+        break;
+      case "om_observation_start":
+      case "om_reflection_start":
+        omActivity = event.type === "om_reflection_start" || event.operationType === "reflection" ? "reflecting" : "observing";
+        updateStatus();
+        break;
+      case "om_buffering_end":
+      case "om_observation_end":
+      case "om_reflection_end":
+        omActivity = null;
+        updateStatus();
+        break;
+      case "om_buffering_failed":
+      case "om_observation_failed":
+      case "om_reflection_failed":
+        omActivity = null;
+        closeSegment();
+        addLine(
+          c.warn(
+            `  Memory ${event.type === "om_buffering_failed" ? `${event.operationType} buffering` : event.type === "om_reflection_failed" ? "reflection" : "observation"} failed: ${event.error}`
+          )
+        );
+        updateStatus();
+        break;
+      case "om_activation":
+        omActivity = null;
+        closeSegment();
+        addLine(
+          c.dim(
+            `  Memory compacted ${shortTokens(event.tokensActivated)} into ${shortTokens(event.observationTokens)} observation tokens.`
+          )
+        );
+        updateStatus();
+        break;
+      case "agent_end":
+        running = false;
+        cancelRequested = false;
+        activeTools.clear();
+        loader.setMessage("Janet is thinking\u2026");
+        if (event.reason !== "suspended") pendingQuestion = null;
+        setLoader(false);
+        updateStatus();
+        break;
+    }
+  };
+  const unsubscribe = session.subscribe(onEvent);
+  let removeInputListener = () => {
+  };
+  let sigintHandler;
+  const shutdown = async (code) => {
+    removeInputListener();
+    if (sigintHandler) process.off("SIGINT", sigintHandler);
+    unsubscribe();
+    herdrDetach();
+    ui.stop();
+    await observability.flush().catch(() => {
+    });
+    await controller.destroy().catch(() => {
+    });
+    process.exit(code);
+  };
+  const notifyInterrupt = (result) => {
+    switch (result) {
+      case "cancelled":
+        addLine(c.dim("  Cancelling the active run\u2026"));
+        break;
+      case "cleared":
+        break;
+      case "exit":
+        break;
+      case "exit-hint":
+        addLine(c.dim("  Press Ctrl+C again to quit."));
+        break;
+    }
+    updateStatus();
+  };
+  const abortActiveRun = () => {
+    if (cancelRequested) return;
+    cancelRequested = true;
+    pendingApproval = null;
+    pendingQuestion = null;
+    activeTools.clear();
+    if (activeSelect) {
+      chat.removeChild(activeSelect);
+      activeSelect = null;
+    }
+    ui.setFocus(editor);
+    loader.setMessage("Cancelling\u2026");
+    session.abort();
+  };
+  const interrupts = createInterruptController({
+    isRunning: () => running,
+    hasInput: () => editor.getText().length > 0,
+    abortRun: abortActiveRun,
+    clearInput: () => {
+      editor.setText("");
+      ui.requestRender();
+    },
+    exit: () => {
+      void shutdown(0);
+    },
+    notify: notifyInterrupt
+  });
+  removeInputListener = ui.addInputListener((data) => {
+    if (matchesKey2(data, "ctrl+c")) {
+      interrupts.handleCtrlC();
+      return { consume: true };
+    }
+    if (matchesKey2(data, "escape") && activeSelect) {
+      return void 0;
+    }
+    if (matchesKey2(data, "escape") && running) {
+      interrupts.handleEscape();
+      return { consume: true };
+    }
+    return void 0;
+  });
+  sigintHandler = () => {
+    interrupts.handleCtrlC();
+  };
+  process.on("SIGINT", sigintHandler);
+  const promptInput = (message, placeholder) => {
+    addLine(c.accentBold(`  ${message}`));
+    if (placeholder) addLine(c.dim(`  (${placeholder})`));
+    return new Promise((resolve) => {
+      pendingInput = resolve;
+      updateStatus();
+    });
+  };
+  const closeActiveSelect = (select) => {
+    chat.removeChild(select);
+    if (activeSelect === select) activeSelect = null;
+    ui.setFocus(editor);
+  };
+  const selectModel = async (modelId) => {
+    try {
+      await session.model.switch({ modelId });
+      completeOnboarding(modelId, (/* @__PURE__ */ new Date()).toISOString());
+      rememberModel(modelId);
+      addLine(c.accentBold(`  \u2713 Using ${modelId}.`) + c.dim("  (saved as your default)"));
+    } catch (error) {
+      addLine(c.error(`  Could not select ${modelId}: ${error.message}`));
+    } finally {
+      updateStatus();
+    }
+  };
+  const showProviderModels = (groups, allChoices) => {
+    const current = session.model.hasSelection() ? session.model.get() : null;
+    const available = groups.flatMap(
+      (group) => group.models.map((choice) => ({ choice, group }))
+    );
+    const currentChoice = available.find(({ choice }) => choice.id === current);
+    const ordered = currentChoice ? [currentChoice, ...available.filter(({ choice }) => choice.id !== current)] : available;
+    const visible = ordered.slice(0, 29);
+    const items = visible.map(({ choice, group }) => ({
+      value: choice.id,
+      label: groups.length > 1 ? `${group.label}: ${choice.label}${choice.id === current ? " (current)" : ""}` : `${choice.label}${choice.id === current ? " (current)" : ""}`,
+      description: choice.id
+    }));
+    items.push({
+      value: "__janet_enter_model_id__",
+      label: "Enter another model ID\u2026",
+      description: ordered.length > visible.length ? `${ordered.length - visible.length} more catalog models; enter the exact id` : groups.length === 1 ? `Use any ${groups[0].id}/model supported by Mastra` : "Use any provider/model supported by Mastra"
+    });
+    addLine(
+      c.accentBold(
+        groups.length === 1 ? `  ${groups[0].label} models` : `  Models from ${groups.length} providers`
+      )
+    );
+    addLine(c.dim("  \u2191/\u2193 to move \xB7 Enter to choose \xB7 Esc to go back:"));
+    const select = new SelectList(
+      items,
+      Math.min(items.length, 10),
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      if (item.value === "__janet_enter_model_id__") {
+        void promptInput(
+          groups.length === 1 ? `Model id for ${groups[0].label}:` : "Full model id:",
+          groups.length === 1 ? `${groups[0].id}/model-name` : "provider/model-name"
+        ).then((input) => {
+          const modelId = groups.length === 1 && !input.includes("/") ? `${groups[0].id}/${input}` : normalizeModelSelection(
+            input,
+            available.map(({ choice }) => choice)
+          );
+          void selectModel(modelId);
+        });
+        return;
+      }
+      void selectModel(item.value);
+    };
+    select.onCancel = () => {
+      closeActiveSelect(select);
+      showProviderPicker(allChoices);
+    };
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const showProviderPicker = (choices) => {
+    const groups = groupModelsByProvider(choices);
+    if (!groups.length) {
+      addLine(c.dim("  No providers are configured yet. Set one up, then try again:"));
+      addLine(c.dim("    \u2022 Vertex AI:   gcloud auth application-default login  (+ GOOGLE_VERTEX_PROJECT)"));
+      addLine(c.dim("    \u2022 Anthropic:   set ANTHROPIC_API_KEY, or /login anthropic"));
+      addLine(c.dim("    \u2022 OpenAI:      set OPENAI_API_KEY, or /login openai-codex"));
+      addLine(c.dim("    \u2022 Bedrock:     configure AWS credentials"));
+      addLine(c.dim("    \u2022 More:        /providers lists native Mastra environment variables"));
+      updateStatus();
+      return;
+    }
+    addLine(
+      c.dim(
+        "  \u2191/\u2193 to move \xB7 Space to toggle \xB7 Enter to view models \xB7 Esc to close:"
+      )
+    );
+    const select = new MultiSelectList(
+      groups.map((group) => ({
+        value: group.id,
+        label: group.label,
+        description: `${group.models.length} model${group.models.length === 1 ? "" : "s"} \xB7 ${group.via}`
+      })),
+      Math.min(groups.length, 10),
+      editorTheme.selectList,
+      groups.map((group) => group.id)
+    );
+    select.onConfirm = (items) => {
+      if (!items.length) {
+        addLine(c.warn("  Select at least one provider."));
+        return;
+      }
+      closeActiveSelect(select);
+      const selectedIds = new Set(items.map((item) => item.value));
+      showProviderModels(
+        groups.filter((group) => selectedIds.has(group.id)),
+        choices
+      );
+    };
+    select.onCancel = () => closeActiveSelect(select);
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const showModelPicker = (intro) => {
+    if (modelPickerLoading) {
+      addLine(c.dim("  The provider catalog is already loading."));
+      return;
+    }
+    if (intro) addLine(c.accentBold(intro));
+    addLine(c.dim("  Loading configured providers\u2026"));
+    modelPickerLoading = true;
+    updateStatus();
+    void discoverAvailableModels(() => controller.listAvailableModels()).then(showProviderPicker).catch((error) => {
+      addLine(c.error(`  Could not load providers: ${error.message}`));
+      showProviderPicker(availableModels());
+    }).finally(() => {
+      modelPickerLoading = false;
+      updateStatus();
+    });
+  };
+  const showProviders = () => {
+    if (running) {
+      addLine(c.dim("  Cancel the active run before opening provider setup."));
+      return;
+    }
+    addLine(c.accentBold("  Model providers"));
+    addLine(c.dim("  Loading provider status\u2026"));
+    void discoverAvailableModels(() => controller.listAvailableModels()).then((choices) => {
+      const groups = groupModelsByProvider(choices);
+      const groupsById = new Map(groups.map((group) => [group.id, group]));
+      const known = [
+        {
+          id: "vertex",
+          label: "Google Vertex AI",
+          setup: "Run gcloud auth application-default login and set GOOGLE_VERTEX_PROJECT."
+        },
+        {
+          id: "amazon-bedrock",
+          label: "Amazon Bedrock",
+          setup: "Configure an AWS credential chain and region."
+        },
+        ...NATIVE_PROVIDER_DEFINITIONS.map((provider) => ({
+          id: provider.id,
+          label: provider.label,
+          setup: `Set ${provider.envVars.join(" or ")}.`
+        }))
+      ];
+      const knownIds = new Set(known.map((provider) => provider.id));
+      const providers = [
+        ...known,
+        ...groups.filter((group) => !knownIds.has(group.id)).map((group) => ({
+          id: group.id,
+          label: group.label,
+          setup: "This provider was discovered through Mastra."
+        }))
+      ];
+      addLine(
+        c.dim(
+          "  \u2191/\u2193 to move \xB7 Space to select providers \xB7 Enter for details \xB7 Esc to close:"
+        )
+      );
+      const select = new MultiSelectList(
+        providers.map((provider) => {
+          const group = groupsById.get(provider.id);
+          return {
+            value: provider.id,
+            label: provider.label,
+            description: group ? `Ready \xB7 ${group.via}` : provider.setup
+          };
+        }),
+        Math.min(providers.length, 12),
+        editorTheme.selectList
+      );
+      select.onConfirm = (items) => {
+        if (!items.length) {
+          addLine(c.warn("  Select at least one provider, or press Esc to close."));
+          return;
+        }
+        closeActiveSelect(select);
+        addLine(c.accentBold("  Provider details"));
+        for (const item of items) {
+          const provider = providers.find((candidate) => candidate.id === item.value);
+          const group = groupsById.get(item.value);
+          if (!provider) continue;
+          if (group) {
+            addLine(
+              c.accent(`  \u2713 ${provider.label}`) + c.dim(` \u2014 ready via ${group.via}`)
+            );
+            continue;
+          }
+          addLine(c.bold(`  ${provider.label}`) + c.dim(` \u2014 ${provider.setup}`));
+          if (provider.id === "anthropic") {
+            addLine(c.dim("    Or use /login anthropic for a Claude subscription."));
+          } else if (provider.id === "openai") {
+            addLine(c.dim("    Or use /login openai-codex for a ChatGPT subscription."));
+          }
+        }
+        addLine(c.dim("  Reopen /providers at any time; /models shows providers ready now."));
+        updateStatus();
+      };
+      select.onCancel = () => closeActiveSelect(select);
+      activeSelect = select;
+      chat.addChild(select);
+      ui.setFocus(select);
+      updateStatus();
+    }).catch((error) => {
+      addLine(c.error(`  Could not load provider status: ${error.message}`));
+      updateStatus();
+    });
+  };
+  const savedObservabilitySummary = () => {
+    const saved = loadSettings().observability;
+    const resolved = resolveObservabilityConfig(saved, {});
+    return formatObservabilityStatus({
+      enabled: resolved.enabled,
+      capture: resolved.capture,
+      sampleRate: resolved.sampleRate,
+      destinations: [
+        ...resolved.local.enabled ? ["local"] : [],
+        ...resolved.remote ? [
+          resolved.remote.kind === "phoenix" ? `phoenix (${safeObservabilityEndpoint(resolved.remote.endpoint)})` : `otlp (${safeObservabilityEndpoint(resolved.remote.endpoint)})`
+        ] : []
+      ],
+      warnings: resolved.warnings
+    });
+  };
+  const persistObservability = (settings) => {
+    rememberObservability(settings);
+    addLine(c.accentBold("  \u2713 Observability settings saved."));
+    addLine(c.dim(`  Saved: ${savedObservabilitySummary()}`));
+    addLine(c.dim("  Restart Janet to apply the new setting."));
+    updateStatus();
+  };
+  const confirmFullCapture = (base) => {
+    addLine(
+      c.warn(
+        "  Full capture includes prompts, responses, and tool payloads. Do not use it with sensitive material."
+      )
+    );
+    addLine(c.dim("  \u2191/\u2193 to move \xB7 Enter to choose \xB7 Esc to go back:"));
+    const select = new SelectList(
+      [
+        {
+          value: "no",
+          label: "Keep metadata-only capture",
+          description: "Recommended. Content stays out of traces."
+        },
+        {
+          value: "yes",
+          label: "Enable full capture",
+          description: "I understand trace content may contain sensitive data."
+        }
+      ],
+      2,
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      persistObservability({
+        ...base,
+        capture: item.value === "yes" ? "full" : "metadata"
+      });
+    };
+    select.onCancel = () => {
+      closeActiveSelect(select);
+      chooseCaptureMode(base);
+    };
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const chooseCaptureMode = (base) => {
+    addLine(c.accentBold("  What may Janet include in traces?"));
+    addLine(c.dim("  \u2191/\u2193 to move \xB7 Enter to choose \xB7 Esc to go back:"));
+    const select = new SelectList(
+      [
+        {
+          value: "metadata",
+          label: "Metadata only",
+          description: "Timing, tool names, model, tokens, status, and errors."
+        },
+        {
+          value: "full",
+          label: "Full content",
+          description: "Also includes prompts, responses, and tool payloads."
+        }
+      ],
+      2,
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      const capture = item.value;
+      if (capture === "full") {
+        confirmFullCapture(base);
+      } else {
+        persistObservability({ ...base, capture });
+      }
+    };
+    select.onCancel = () => {
+      closeActiveSelect(select);
+      showObservabilityPicker();
+    };
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const showObservabilityPicker = () => {
+    if (running) {
+      addLine(c.dim("  Cancel the active run before changing observability settings."));
+      return;
+    }
+    addLine(c.accentBold("  Configure observability"));
+    addLine(c.dim(`  Active now: ${formatObservabilityStatus(observability.status)}`));
+    addLine(c.dim("  Tracing is opt-in and changes apply after restart."));
+    addLine(c.dim("  \u2191/\u2193 to move \xB7 Enter to choose \xB7 Esc to close:"));
+    const select = new SelectList(
+      [
+        {
+          value: "off",
+          label: "Off",
+          description: "No spans, trace database, or network export."
+        },
+        {
+          value: "local",
+          label: "Local trace history",
+          description: "Store traces in ~/.agent-knowledge/observability.db."
+        },
+        {
+          value: "phoenix",
+          label: "Phoenix",
+          description: "Send OTLP traces to http://localhost:6006."
+        },
+        {
+          value: "otlp",
+          label: "Custom OTLP",
+          description: "Send OTLP/HTTP protobuf traces to your endpoint."
+        }
+      ],
+      4,
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      if (item.value === "off") {
+        persistObservability({
+          capture: "off",
+          sampleRate: 1,
+          local: { enabled: false, retentionDays: 7 }
+        });
+        return;
+      }
+      if (item.value === "local") {
+        chooseCaptureMode({
+          sampleRate: 1,
+          local: { enabled: true, retentionDays: 7 }
+        });
+        return;
+      }
+      if (item.value === "phoenix") {
+        chooseCaptureMode({
+          sampleRate: 1,
+          local: { enabled: false, retentionDays: 7 },
+          remote: {
+            kind: "phoenix",
+            endpoint: "http://localhost:6006",
+            projectName: "janet"
+          }
+        });
+        return;
+      }
+      void promptInput(
+        "OTLP endpoint (for example, http://localhost:4318):"
+      ).then((endpoint) => {
+        try {
+          const parsed = new URL(endpoint);
+          if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error();
+          if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+            addLine(
+              c.error(
+                "  Do not put credentials or query parameters in the saved endpoint. Use OTEL_EXPORTER_OTLP_HEADERS."
+              )
+            );
+            return;
+          }
+        } catch {
+          addLine(c.error("  Endpoint must be a valid HTTP or HTTPS URL."));
+          return;
+        }
+        chooseCaptureMode({
+          sampleRate: 1,
+          local: { enabled: false, retentionDays: 7 },
+          remote: {
+            kind: "otlp",
+            endpoint
+          }
+        });
+      });
+    };
+    select.onCancel = () => closeActiveSelect(select);
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const showLocalTraces = async () => {
+    if (running) {
+      addLine(c.dim("  Cancel the active run before browsing traces."));
+      return;
+    }
+    if (!observability.config.local.enabled) {
+      addLine(c.dim("  Local trace history is not active. Use /observability to enable it."));
+      return;
+    }
+    await observability.flush().catch(() => {
+    });
+    const store = await observability.storage.getStore("observability");
+    if (!store) {
+      addLine(c.error("  Local trace storage is unavailable."));
+      return;
+    }
+    const recent = await store.listTraces({
+      pagination: { page: 0, perPage: 10 },
+      orderBy: { field: "startedAt", direction: "DESC" }
+    });
+    if (!recent.spans.length) {
+      addLine(c.dim("  No local traces yet."));
+      return;
+    }
+    addLine(c.accentBold("  Recent local traces"));
+    addLine(c.dim("  \u2191/\u2193 to move \xB7 Enter to open \xB7 Esc to close:"));
+    const select = new SelectList(
+      recent.spans.map((span) => {
+        const state = traceStatus(span);
+        const marker = state === "error" ? "\u2717" : state === "running" ? "\u2026" : "\u2713";
+        return {
+          value: span.traceId,
+          label: `${marker} ${span.name}`,
+          description: `${span.startedAt.toLocaleString()} \xB7 ${span.traceId}`
+        };
+      }),
+      Math.min(recent.spans.length, 10),
+      editorTheme.selectList
+    );
+    select.onSelect = (item) => {
+      closeActiveSelect(select);
+      void store.getTrace({ traceId: item.value }).then((trace) => {
+        if (!trace) {
+          addLine(c.error(`  Trace not found: ${item.value}`));
+          return;
+        }
+        addLine(c.accentBold(`  Trace ${trace.traceId}`));
+        for (const line of formatTraceTree(trace.spans)) {
+          addLine(c.dim(`  ${line}`));
+        }
+      }).catch((error) => {
+        addLine(c.error(`  Could not read trace: ${error.message}`));
+      });
+    };
+    select.onCancel = () => closeActiveSelect(select);
+    activeSelect = select;
+    chat.addChild(select);
+    ui.setFocus(select);
+    updateStatus();
+  };
+  const handleCommand = async (text) => {
+    const [cmd, ...rest] = text.slice(1).split(/\s+/);
+    switch (cmd) {
+      case "quit":
+      case "exit":
+        await shutdown(0);
+        break;
+      case "help":
+        addLine(c.dim(HELP_TEXT));
+        break;
+      case "cancel":
+        if (interrupts.handleEscape() === "ignored") {
+          addLine(c.dim("  No active run to cancel."));
+        }
+        break;
+      case "clear":
+        if (running || compacting) {
+          addLine(c.dim("  Wait for the active work to finish before clearing the conversation."));
+          break;
+        }
+        try {
+          await clearConversation(session.thread);
+          active = null;
+          activeTools.clear();
+          omWindows = null;
+          omActivity = null;
+          chat.clear();
+          addLine(c.accentBold(GREETING));
+          addLine(c.accentBold("  \u2713 Conversation cleared."));
+          addLine(c.dim(`  Knowledge bundle: ${paths.bundlePath}`));
+          addLine(c.dim("  The previous conversation is still saved as a separate thread."));
+        } catch (error) {
+          addLine(c.error(`  Could not clear the conversation: ${error.message}`));
+        } finally {
+          updateStatus();
+        }
+        break;
+      case "compact": {
+        if (running || compacting) {
+          addLine(c.dim("  Wait for the active work to finish before compacting memory."));
+          break;
+        }
+        if (!session.model.hasSelection()) {
+          addLine(c.dim("  Pick a model before compacting memory."));
+          break;
+        }
+        const threadId = session.thread.getId();
+        if (!threadId) {
+          addLine(c.dim("  There is no active conversation to compact."));
+          break;
+        }
+        compacting = true;
+        loader.setMessage("Janet is compacting memory\u2026");
+        setLoader(true);
+        updateStatus();
+        try {
+          const requestContext = await session.machinery.buildRequestContext();
+          const agent = controller.getCurrentAgent(session);
+          const memory = await agent.getMemory({ requestContext });
+          if (!memory) throw new Error("Janet memory is unavailable.");
+          const result = await compactConversation({
+            memory,
+            agent,
+            threadId,
+            resourceId: session.identity.getResourceId(),
+            requestContext
+          });
+          if (!result.buffered && !result.activated && !result.reflected) {
+            addLine(c.dim("  Memory is already compact."));
+          } else {
+            const reflected = result.reflected ? " and reflected" : "";
+            addLine(
+              c.accentBold(
+                `  \u2713 Compacted ~${result.pendingTokensBefore.toLocaleString()} message tokens into ~${result.observationTokens.toLocaleString()} memory tokens${reflected}.`
+              )
+            );
+            addLine(c.dim("  Raw messages remain available to Janet through memory recall."));
+          }
+        } catch (error) {
+          addLine(c.error(`  Could not compact memory: ${error.message}`));
+        } finally {
+          compacting = false;
+          loader.setMessage("Janet is thinking\u2026");
+          setLoader(false);
+          updateStatus();
+        }
+        break;
+      }
+      case "observability": {
+        const action = rest[0]?.trim().toLowerCase();
+        if (action === "status") {
+          addLine(c.dim(`  Active: ${formatObservabilityStatus(observability.status)}`));
+          addLine(c.dim(`  Saved:  ${savedObservabilitySummary()}`));
+        } else if (action === "off") {
+          persistObservability({
+            capture: "off",
+            sampleRate: 1,
+            local: { enabled: false, retentionDays: 7 }
+          });
+        } else if (!action) {
+          showObservabilityPicker();
+        } else {
+          addLine(c.dim("Usage: /observability [status | off]"));
+        }
+        break;
+      }
+      case "traces":
+        await showLocalTraces();
+        break;
+      case "login": {
+        const providerId = (rest[0] || "anthropic").trim();
+        if (!OAUTH_PROVIDERS.includes(providerId)) {
+          addLine(c.dim(`Usage: /login <${OAUTH_PROVIDERS.join(" | ")}>`));
+          break;
+        }
+        const authMode = rest[1]?.trim();
+        if (authMode && (providerId !== "openai-codex" || !["browser", "device"].includes(authMode))) {
+          addLine(c.dim("Usage: /login openai-codex [browser | device]"));
+          break;
+        }
+        addLine(c.dim(`Starting ${providerId} login\u2026`));
+        try {
+          await getAuthStorage().login(providerId, {
+            onAuth: (info) => {
+              addLine(c.accent("  Open this URL in your browser to authorize:"));
+              addLine("  " + info.url);
+              if (info.instructions) addLine(c.dim("  " + info.instructions));
+            },
+            onProgress: (m) => addLine(c.dim("  " + m)),
+            onManualCodeInput: () => promptInput("Paste the code shown after you authorize:"),
+            onPrompt: (p) => promptInput(p.message, p.placeholder),
+            ...authMode ? { authMode } : {}
+          });
+          addLine(c.accentBold(`  \u2713 Logged in to ${providerId}.`));
+          updateStatus();
+        } catch (err) {
+          addLine(c.error(`  Login failed: ${err.message}`));
+        } finally {
+          pendingInput = null;
+          updateStatus();
+        }
+        break;
+      }
+      case "logout": {
+        const providerId = rest[0]?.trim();
+        if (!providerId) {
+          addLine(c.dim(`Usage: /logout <${OAUTH_PROVIDERS.join(" | ")}>`));
+          break;
+        }
+        const storage = getAuthStorage();
+        storage.logout(providerId);
+        storage.remove(`apikey:${providerId}`);
+        addLine(c.dim(`Logged out of ${providerId}.`));
+        break;
+      }
+      case "auth": {
+        const storage = getAuthStorage();
+        storage.reload();
+        const providers = storage.list();
+        if (!providers.length) {
+          addLine(c.dim("No stored credentials. Use /login <provider>, or set an API key env var"));
+          addLine(c.dim("(ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_VERTEX_PROJECT, AWS_*)."));
+        } else {
+          for (const p of providers) {
+            const cred = storage.get(p);
+            addLine(c.dim(`  ${p}: `) + (cred?.type === "oauth" ? c.accent("OAuth (subscription)") : "API key"));
+          }
+        }
+        break;
+      }
+      case "model": {
+        const inputId = rest.join(" ").trim();
+        if (!inputId) {
+          showModelPicker();
+          break;
+        }
+        const id = normalizeModelSelection(inputId, availableModels());
+        await selectModel(id);
+        break;
+      }
+      case "models":
+        showModelPicker();
+        break;
+      case "providers":
+        showProviders();
+        break;
+      default:
+        addLine(c.dim(`Unknown command /${cmd}. Try /help.`));
+    }
+  };
+  editor.onSubmit = (raw) => {
+    const text = raw.trim();
+    editor.setText("");
+    if (!text) return;
+    if (!pendingInput && !pendingApproval && !pendingQuestion) {
+      editor.addToHistory(text);
+    }
+    if (pendingInput) {
+      const resolve = pendingInput;
+      pendingInput = null;
+      addLine(c.dim("  \u276F (value entered)"));
+      updateStatus();
+      resolve(text);
+      return;
+    }
+    if (pendingQuestion && !activeSelect) {
+      const resumeData = resolveAnswer(pendingQuestion, text);
+      if (resumeData === void 0) {
+        addLine(c.dim("  Didn't match an option \u2014 reply with a number or an exact label."));
+        return;
+      }
+      answerQuestion(resumeData, Array.isArray(resumeData) ? resumeData.join(", ") : resumeData);
+      return;
+    }
+    if (pendingApproval) {
+      const approve = /^y(es)?$/i.test(text);
+      const decline = /^n(o)?$/i.test(text);
+      const always = /^a(lways)?$/i.test(text);
+      if (approve || decline || always) {
+        const { toolCallId } = pendingApproval;
+        pendingApproval = null;
+        addLine(c.dim(always ? "  \u2713 always allowed" : approve ? "  \u2713 approved" : "  \u2717 declined"));
+        updateStatus();
+        void session.respondToToolApproval({
+          decision: always ? "always_allow_category" : approve ? "approve" : "decline",
+          toolCallId
+        });
+        return;
+      }
+      addLine(c.dim("  Answer y (yes), n (no), or a (always allow) first."));
+      return;
+    }
+    if (compacting) {
+      addLine(c.dim("  Janet is still compacting memory; try again in a moment."));
+      return;
+    }
+    if (text.startsWith("/")) {
+      void handleCommand(text);
+      return;
+    }
+    addLine(c.user(`\u276F ${text}`));
+    if (!session.model.hasSelection()) {
+      showModelPicker("  Pick a model first:");
+      return;
+    }
+    void session.sendMessage({
+      content: text,
+      tracingOptions: observability.tracingOptionsForTurn({
+        interactive: true,
+        operation: "chat",
+        resourceId: paths.resourceId,
+        threadId: session.thread.getId() ?? void 0
+      })
+    }).catch((err) => {
+      running = false;
+      setLoader(false);
+      addLine(c.error(`  \u2717 ${err.message}`));
+      updateStatus();
+    });
+  };
+  addLine(c.accentBold(GREETING));
+  addLine(
+    c.dim(
+      `Knowledge bundle: ${paths.bundlePath}
+Ask me anything in the bundle, or say what to ingest. /help for commands.`
+    )
+  );
+  for (const warning of observability.status.warnings) {
+    addLine(c.warn(`Observability: ${warning}`));
+  }
+  updateStatus();
+  ui.start();
+  ui.setFocus(editor);
+  ui.requestRender();
+  if (!session.model.hasSelection()) showModelPicker("  Let's pick a model to get you started.");
+  return await new Promise(() => {
+  });
+}
+export {
+  runTui
+};
+//# sourceMappingURL=tui-74FJW5Y4.js.map