neagen 0.1.0 → 0.1.1

package/lib/ansi.mjs

@@ -0,0 +1,2 @@
+export const dim = (text) => `\x1b[2m${text}\x1b[0m`;
+export const bold = (text) => `\x1b[1m${text}\x1b[0m`;

package/lib/api.mjs

@@ -1,5 +1,4 @@
 const DEFAULT_TIMEOUT_MS = 8_000;
-
 export async function probeHost(host) {
   const res = await fetch(`${host}/eve/v1/health`, {
     signal: AbortSignal.timeout(5_000),
@@ -8,7 +7,7 @@ export async function probeHost(host) {
   return true;
 }
 
-export async function apiFetch(host, path, { token, method = "GET", body } = {}) {
+export async function apiFetch(host, path, { token, method = "GET", body, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
   const res = await fetch(`${host}${path}`, {
     method,
     headers: {
@@ -16,12 +15,24 @@ export async function apiFetch(host, path, { token, method = "GET", body } = {})
       ...(body ? { "content-type": "application/json" } : {}),
     },
     body: body ? JSON.stringify(body) : undefined,
-    signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+    signal: AbortSignal.timeout(timeoutMs),
   });
   const data = await res.json().catch(() => null);
   return { res, data };
 }
 
+function apiErrorMessage(res, data) {
+  const serverMessage = data?.error?.message;
+  if (serverMessage) return serverMessage;
+  return `HTTP ${res.status}`;
+}
+
+export async function apiRequest(host, path, { token, method = "GET", body, timeoutMs } = {}) {
+  const { res, data } = await apiFetch(host, path, { token, method, body, timeoutMs });
+  if (!res.ok) throw new Error(apiErrorMessage(res, data));
+  return data;
+}
+
 /** Resolve owner identity — /api/me when deployed, else Ably token clientId. */
 export async function resolveIdentity(host, token) {
   const me = await apiFetch(host, "/api/me", { token });
@@ -54,3 +65,20 @@ export async function resolveIdentity(host, token) {
       : (ably.data?.error?.message ?? `identity check failed (${ably.res.status})`),
   );
 }
+
+export async function getSelectedModel(host, token) {
+  return apiRequest(host, "/api/models/selection", { token });
+}
+
+export async function selectModel(host, token, modelId) {
+  return apiRequest(host, "/api/models/selection", {
+    token,
+    method: "PATCH",
+    body: { modelId },
+  });
+}
+
+export async function listModels(host, token) {
+  const data = await apiRequest(host, "/api/models", { token });
+  return data?.models ?? [];
+}

package/lib/device-login.mjs

@@ -4,8 +4,8 @@
 // approval page (${host}/device), and polls ${host}/api/auth/device/token until
 // the Owner approves. The grant only ever mints a session for an ALREADY-EXISTING
 // account — it can never create one — so a brand-new user must first create their
-// account on the web (the /device page bounces them to sign-up). Passkey stays the
-// identity root.
+// account on the web (the /device page bounces them to sign-in; first-timers toggle
+// to sign-up on that screen). Passkey stays the identity root.
 
 import { execFile } from "node:child_process";
 import { saveCreds } from "./creds.mjs";
@@ -85,10 +85,12 @@ export async function runDeviceGrantLogin({ host, profile, renderer }) {
 
     ui.renderLine(`Your code:  ${code.user_code}`, "info");
     ui.renderLine(code.verification_uri_complete, "info");
-    ui.renderLine("Opening your browser — approve with your passkey…", "info");
+    ui.renderLine("Opening your browser — create or sign in, then approve…", "info");
     // Mirror to stderr so login is never silent if the panel hasn't painted yet.
     console.error(
-      `\n  Your code:   ${code.user_code}\n  Approve at:  ${code.verification_uri_complete}\n`,
+      `\n  Your code:   ${code.user_code}\n  Approve at:  ${code.verification_uri_complete}\n\n` +
+        `  Returning? Sign in with your passkey on that page, then approve this device.\n` +
+        `  First time? Switch to create your Neagen on that page. Use the same browser throughout.\n`,
     );
     openBrowser(code.verification_uri_complete);
 

package/lib/eve-chat.mjs

@@ -0,0 +1,170 @@
+import { Client } from "eve/client";
+
+export function createEveClient(host, token) {
+  return new Client({
+    host,
+    auth: { bearer: token },
+    preserveCompletedSessions: true,
+    redirect: "manual",
+  });
+}
+
+export function summarizeResult(result) {
+  const neagenBody = cleanReply(result?.neagenMessage?.body);
+  if (neagenBody) return neagenBody;
+  const message = cleanReply(result?.message);
+  if (message) return message;
+  if (result?.runtimeStatus === "waiting") return "(waiting)";
+  if (result?.status) return `(${result.status})`;
+  return "(no reply)";
+}
+
+function cleanReply(value) {
+  if (typeof value !== "string") return undefined;
+  const text = value.trim();
+  if (!text || text === "undefined" || text === "null") return undefined;
+  return text;
+}
+
+export function requestToolName(request) {
+  return request?.action?.toolName ?? "input";
+}
+
+function preview(value) {
+  if (typeof value !== "string") return undefined;
+  return value.length > 120 ? `${value.slice(0, 117)}...` : value;
+}
+
+export function formatRequestDetails(request) {
+  const input = request?.action?.input;
+  if (!input || typeof input !== "object") return "";
+  const parts = [];
+  if (typeof input.to === "string") parts.push(`to: ${input.to}`);
+  if (typeof input.path === "string") parts.push(`path: ${input.path}`);
+  if (typeof input.draftId === "string") parts.push(`draft: ${input.draftId}`);
+  const body = preview(input.body);
+  if (body !== undefined) parts.push(`body: ${JSON.stringify(body)}`);
+  return parts.join(", ");
+}
+
+export function pickOption(request, approved) {
+  const options = request?.options ?? [];
+  const pattern = approved ? /approve|allow|yes|confirm/i : /deny|reject|no|cancel/i;
+  return (
+    options.find((option) => pattern.test(`${option.id} ${option.label}`)) ??
+    options[approved ? 0 : options.length - 1]
+  );
+}
+
+export function approvalResponse(request, approved) {
+  const option = pickOption(request, approved);
+  return { requestId: request.requestId, optionId: option?.id ?? (approved ? "approve" : "deny") };
+}
+
+export function questionResponse(request, answer) {
+  const value = answer.trim();
+  const numeric = Number(value);
+  const option = Number.isInteger(numeric) ? request.options?.[numeric - 1] : undefined;
+  if (option) return { requestId: request.requestId, optionId: option.id };
+
+  const byText = request.options?.find((entry) => {
+    const haystack = `${entry.id} ${entry.label}`.toLowerCase();
+    return haystack === value.toLowerCase() || entry.label.toLowerCase() === value.toLowerCase();
+  });
+  if (byText) return { requestId: request.requestId, optionId: byText.id };
+
+  return { requestId: request.requestId, text: answer };
+}
+
+export function wakeSyncPrompt(event) {
+  return (
+    `[mail] You just received new mail (${event.kind === "message" ? "a text message" : "a file"}) from a connection. ` +
+    "Call sync_inbox once to fetch it, then tell me in one short line who it is from and what it is."
+  );
+}
+
+export async function settleInputRequests(result, session, handlers) {
+  let settled = result;
+  while ((settled.inputRequests?.length ?? 0) > 0) {
+    const request = settled.inputRequests[0];
+    const response =
+      requestToolName(request) === "ask_question"
+        ? questionResponse(request, await handlers.askQuestion(request))
+        : approvalResponse(request, await handlers.askApproval(request));
+
+    const resumed = await session.send({ inputResponses: [response] });
+    settled = await resumed.result();
+  }
+  return settled;
+}
+
+export async function sendEveTurn(session, message, options = {}) {
+  const response = await session.send({
+    message,
+    ...(options.clientContext ? { clientContext: options.clientContext } : {}),
+  });
+  const result = await response.result();
+  return options.settle ? options.settle(result, session) : result;
+}
+
+function parseSseEvents(text) {
+  return text
+    .split(/\n\n+/)
+    .map((chunk) => {
+      const event = chunk.match(/^event: (.+)$/m)?.[1];
+      const data = chunk.match(/^data: (.+)$/m)?.[1];
+      if (!event || !data) return undefined;
+      return { event, data: JSON.parse(data) };
+    })
+    .filter(Boolean);
+}
+
+async function postTurn(host, token, body) {
+  const res = await fetch(`${host.replace(/\/$/, "")}/api/turns`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      accept: "text/event-stream",
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(120_000),
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    let message = `HTTP ${res.status}`;
+    try {
+      message = JSON.parse(text)?.error?.message ?? message;
+    } catch {
+      if (text.trim()) message = text.trim();
+    }
+    throw new Error(message);
+  }
+  return parseSseEvents(text).find((entry) => entry.event === "turn")?.data;
+}
+
+export async function sendWakeSyncTurn({ host, token, event, handlers }) {
+  return sendTransportTurn({
+    host,
+    token,
+    conversationId: undefined,
+    message: wakeSyncPrompt(event),
+    handlers,
+  });
+}
+
+export async function sendTransportTurn({ host, token, conversationId, message, handlers }) {
+  let result = await postTurn(host, token, { conversationId, body: message });
+  while ((result?.inputRequests?.length ?? 0) > 0) {
+    const request = result.inputRequests[0];
+    const response =
+      requestToolName(request) === "ask_question"
+        ? questionResponse(request, await handlers.askQuestion(request))
+        : approvalResponse(request, await handlers.askApproval(request));
+    result = await postTurn(host, token, {
+      conversationId: result.conversationId,
+      inputResponses: [response],
+    });
+  }
+  return result;
+}

package/lib/picker.mjs

@@ -0,0 +1,280 @@
+// Interactive terminal picker — type to filter, arrows to move, enter to select.
+
+import { emitKeypressEvents } from "node:readline";
+import { stdin, stdout } from "node:process";
+import { dim, bold } from "./ansi.mjs";
+import { slashCommandMatches, slashCompletionSuffix } from "./slash.mjs";
+
+const DEFAULT_WINDOW = 10;
+
+/**
+ * @param {import("node:readline/promises").Interface} rl
+ * @param {object} options
+ * @param {readonly unknown[]} options.items
+ * @param {(item: unknown, filter: string) => boolean} options.matchItem
+ * @param {(item: unknown, selected: boolean, active: boolean) => string} options.formatRow
+ * @param {string[]} options.headerLines
+ * @param {number} [options.windowSize]
+ * @param {number} [options.initialIndex]
+ */
+export function runPicker(rl, options) {
+  const {
+    items,
+    matchItem,
+    formatRow,
+    headerLines,
+    windowSize = DEFAULT_WINDOW,
+    initialIndex = 0,
+  } = options;
+
+  return new Promise((resolve) => {
+    let filter = "";
+    let view = [...items];
+    let index = Math.min(Math.max(0, initialIndex), Math.max(0, view.length - 1));
+    let offset = Math.max(0, Math.min(index - 2, Math.max(0, view.length - windowSize)));
+
+    const refilter = () => {
+      view = items.filter((item) => matchItem(item, filter));
+      index = 0;
+      offset = 0;
+    };
+
+    rl.pause();
+    const prevRaw = stdin.isRaw;
+    const savedKeypress = stdin.listeners("keypress");
+    stdin.removeAllListeners("keypress");
+    emitKeypressEvents(stdin);
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+
+    let lastLines = 0;
+    const clearRender = () => {
+      if (lastLines > 0) stdout.write(`\x1b[${lastLines}A\x1b[J`);
+    };
+    const render = () => {
+      clearRender();
+      const lines = [...headerLines, dim(`  filter: ${filter || "(all)"}   ·   ${view.length} match`)];
+      if (view.length === 0) {
+        lines.push(dim("    no matches"));
+      } else {
+        for (let i = offset; i < Math.min(offset + windowSize, view.length); i++) {
+          lines.push(formatRow(view[i], i === index, false));
+        }
+      }
+      stdout.write(`${lines.join("\n")}\n`);
+      lastLines = lines.length;
+    };
+
+    const finish = (result) => {
+      stdin.removeListener("keypress", onKey);
+      clearRender();
+      if (stdin.isTTY) stdin.setRawMode(prevRaw);
+      stdin.removeAllListeners("keypress");
+      for (const listener of savedKeypress) stdin.on("keypress", listener);
+      rl.resume();
+      resolve(result);
+    };
+
+    function onKey(str, key) {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") return finish(null);
+      if (key.name === "escape") return finish(null);
+      if (key.name === "return" || key.name === "enter") return finish(view[index] ?? null);
+      if (key.name === "up") {
+        if (index > 0) index--;
+      } else if (key.name === "down") {
+        if (index < view.length - 1) index++;
+      } else if (key.name === "backspace") {
+        filter = filter.slice(0, -1);
+        refilter();
+      } else if (str && str.length === 1 && !key.ctrl && !key.meta && str >= " ") {
+        filter += str;
+        refilter();
+      } else {
+        return;
+      }
+      if (index < offset) offset = index;
+      if (index >= offset + windowSize) offset = index - windowSize + 1;
+      render();
+    }
+
+    stdin.on("keypress", onKey);
+    render();
+  });
+}
+
+export function pickModel(rl, models, activeId) {
+  const initialIndex = Math.max(0, models.findIndex((model) => model.id === activeId));
+  return runPicker(rl, {
+    items: models,
+    initialIndex,
+    headerLines: [dim("  pick a model — type to filter · ↑/↓ move · enter select · esc cancel")],
+    matchItem: (model, filter) => {
+      const haystack = `${model.name ?? ""} ${model.providerLabel ?? ""} ${model.id}`.toLowerCase();
+      return haystack.includes(filter.toLowerCase());
+    },
+    formatRow: (model, selected, _active) => {
+      const arrow = selected ? bold("›") : " ";
+      const mark = model.id === activeId ? "●" : " ";
+      const name = selected ? bold(model.name ?? model.id) : (model.name ?? model.id);
+      const meta = dim(
+        `${model.providerLabel ?? ""} · $${model.inputUsdPerMillionTokens ?? "?"}/$${model.outputUsdPerMillionTokens ?? "?"} per M`,
+      );
+      return `  ${arrow} ${mark} ${name}  ${meta}`;
+    },
+  });
+}
+
+export function pickSlashCommand(rl, commands) {
+  return runPicker(rl, {
+    items: commands,
+    headerLines: [dim("  pick a command — type to filter · ↑/↓ move · enter select · esc cancel")],
+    matchItem: (entry, filter) => {
+      const haystack = `${entry.cmd} ${entry.help}`.toLowerCase();
+      return haystack.includes(filter.toLowerCase());
+    },
+    formatRow: (entry, selected) => {
+      const arrow = selected ? bold("›") : " ";
+      const cmd = selected ? bold(entry.cmd) : entry.cmd;
+      return `  ${arrow} ${cmd.padEnd(11)} ${dim(entry.help)}`;
+    },
+  });
+}
+
+export function readPromptLine(rl, options) {
+  const {
+    prompt,
+    slashCommands = [],
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    let selectedIndex = 0;
+    let matches = [];
+    let lastLines = 0;
+
+    function visibleSlashMatches() {
+      if (!buffer.startsWith("/") || buffer.includes(" ")) return [];
+      return slashCommandMatches(buffer, slashCommands);
+    }
+
+    function clampSelection() {
+      if (matches.length === 0) {
+        selectedIndex = 0;
+        return;
+      }
+      selectedIndex = Math.max(0, Math.min(selectedIndex, matches.length - 1));
+    }
+
+    function clearRender() {
+      if (lastLines > 0) stdout.write(`\x1b[${lastLines}A\x1b[J`);
+    }
+
+    function render() {
+      matches = visibleSlashMatches();
+      clampSelection();
+
+      clearRender();
+      const suffix = slashCompletionSuffix(buffer);
+      const lines = [`${prompt}${buffer}${suffix ? dim(suffix) : ""}`];
+
+      if (buffer.startsWith("/") && !buffer.includes(" ")) {
+        lines.push(dim("  pick a command - type to filter · ↑/↓ move · tab complete · enter select"));
+        if (matches.length === 0) {
+          lines.push(dim("    no matches"));
+        } else {
+          for (let i = 0; i < matches.length; i++) {
+            const entry = matches[i];
+            const arrow = i === selectedIndex ? bold("›") : " ";
+            const cmd = i === selectedIndex ? bold(entry.cmd) : entry.cmd;
+            lines.push(`  ${arrow} ${cmd.padEnd(11)} ${dim(entry.help)}`);
+          }
+        }
+      }
+
+      stdout.write(`${lines.join("\n")}\n`);
+      lastLines = lines.length;
+    }
+
+    function finish(value) {
+      stdin.removeListener("keypress", onKey);
+      clearRender();
+      if (value !== null) stdout.write(`${prompt}${value}\n`);
+      if (stdin.isTTY) stdin.setRawMode(prevRaw);
+      stdin.removeAllListeners("keypress");
+      for (const listener of savedKeypress) stdin.on("keypress", listener);
+      rl.resume();
+      resolve(value);
+    }
+
+    function acceptSlashSelection() {
+      if (!buffer.startsWith("/") || buffer.includes(" ")) return false;
+      const suffix = slashCompletionSuffix(buffer);
+      if (suffix) {
+        buffer += suffix;
+        return true;
+      }
+      if (matches.length === 0) return false;
+      buffer = matches[selectedIndex]?.cmd ?? buffer;
+      return true;
+    }
+
+    function onKey(str, key) {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") return finish(null);
+      if (key.ctrl && key.name === "d" && buffer.length === 0) return finish(null);
+      if (key.name === "return" || key.name === "enter") {
+        if (acceptSlashSelection()) return finish(buffer);
+        return finish(buffer);
+      }
+      if (key.name === "tab") {
+        const suffix = slashCompletionSuffix(buffer);
+        if (suffix) {
+          buffer += suffix;
+          selectedIndex = 0;
+          return render();
+        }
+        if (acceptSlashSelection()) return render();
+        return;
+      }
+      if (key.name === "escape") {
+        buffer = "";
+        selectedIndex = 0;
+        return render();
+      }
+      if (key.name === "backspace") {
+        buffer = buffer.slice(0, -1);
+        selectedIndex = 0;
+        return render();
+      }
+      if (key.name === "up" && matches.length > 0) {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        return render();
+      }
+      if (key.name === "down" && matches.length > 0) {
+        selectedIndex = Math.min(matches.length - 1, selectedIndex + 1);
+        return render();
+      }
+      if (str && str.length === 1 && !key.ctrl && !key.meta && str >= " ") {
+        buffer += str;
+        selectedIndex = 0;
+        return render();
+      }
+    }
+
+    rl.pause();
+    const prevRaw = stdin.isRaw;
+    const savedKeypress = stdin.listeners("keypress");
+    stdin.removeAllListeners("keypress");
+    emitKeypressEvents(stdin);
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+
+    try {
+      stdin.on("keypress", onKey);
+      render();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}

package/lib/slash.mjs

@@ -0,0 +1,49 @@
+// Slash commands for the neagen TUI — single source for /help and command selection.
+
+export const SLASH_COMMANDS = [
+  { cmd: "/model", help: "pick a model — type to filter, arrows to move, enter to select" },
+  { cmd: "/new", help: "start a fresh conversation" },
+  { cmd: "/help", help: "show commands" },
+  { cmd: "/exit", help: "quit (also /quit, Ctrl-D, Ctrl-C)" },
+];
+
+/** Hidden alias — completable, not listed in /help. */
+export const SLASH_ALIASES = ["/quit"];
+
+export const SLASH_NAMES = [...SLASH_COMMANDS.map((entry) => entry.cmd), ...SLASH_ALIASES];
+
+export function slashQuery(line) {
+  if (!line.startsWith("/") || line.includes(" ")) return null;
+  return line.toLowerCase();
+}
+
+export function slashCommandMatches(line, commands = SLASH_COMMANDS) {
+  const query = slashQuery(line);
+  if (query === null) return [];
+  return commands.filter((entry) => entry.cmd.toLowerCase().startsWith(query));
+}
+
+export function slashCompletionSuffix(line) {
+  const query = slashQuery(line);
+  if (query === null) return "";
+  const hits = SLASH_NAMES.filter((name) => name.toLowerCase().startsWith(query));
+  if (hits.length !== 1) return "";
+  return hits[0].slice(line.length);
+}
+
+/**
+ * readline completer: Tab-completes slash commands on the command word only
+ * (leading "/" with no space yet) so Tab never hijacks normal chat input.
+ */
+export function completeSlash(line) {
+  if (!line.startsWith("/") || line.includes(" ")) return [[], line];
+  const query = line.toLowerCase();
+  const hits = SLASH_NAMES.filter((name) => name.startsWith(query));
+  return [hits, line];
+}
+
+export function slashHelpLines() {
+  const rows = SLASH_COMMANDS.map(({ cmd, help }) => `  ${cmd.padEnd(11)} ${help}`);
+  rows.push("  (type / to open the command selector; Tab accepts the prefill)");
+  return rows;
+}

package/lib/tui.mjs

@@ -1,28 +1,30 @@
-// neagen TUI — chat, agent-mail, files against the deployed agent.
-// Login happens here (device-grant panel) when no valid session exists.
-//
-// Resolves Eve's TUI internals from the INSTALLED `eve` package (via
-// require.resolve), so it works no matter where npm puts the dependency — global
-// install, npx cache, or this repo's node_modules. `eve` is a hard dependency of
-// this package (see ../package.json), pinned to an exact version because these
-// dist paths are internal to that version.
-
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { Client } from "eve/client";
+// neagen CLI — chat through Neagen's server-mediated turn transport.
+// Login happens here (device grant) when no valid session exists.
+
+import readline from "node:readline/promises";
+import { clearLine, cursorTo } from "node:readline";
+import { stdin } from "node:process";
+import { dim, bold } from "./ansi.mjs";
 import { assertTransportSafe, clearCreds, loadToken, resolveHost } from "./creds.mjs";
-import { probeHost, resolveIdentity } from "./api.mjs";
+import {
+  getSelectedModel,
+  listModels,
+  probeHost,
+  resolveIdentity,
+  selectModel,
+} from "./api.mjs";
 import { runDeviceGrantLogin } from "./device-login.mjs";
-import { panel } from "./flow.mjs";
+import {
+  formatRequestDetails,
+  requestToolName,
+  sendTransportTurn,
+  sendWakeSyncTurn,
+  summarizeResult,
+} from "./eve-chat.mjs";
+import { pickModel, readPromptLine } from "./picker.mjs";
+import { SLASH_COMMANDS, slashHelpLines } from "./slash.mjs";
 import { subscribeInboxWakeAbly } from "./wake.mjs";
 
-const require = createRequire(import.meta.url);
-// `eve` exposes "./package.json" in its exports map, so this resolves the
-// installed package root regardless of hoisting.
-const EVE_DIST = join(dirname(require.resolve("eve/package.json")), "dist", "src");
-const EVE_TUI = join(EVE_DIST, "cli", "dev", "tui");
-
 const profile = process.env.NEAGEN_PROFILE?.trim() || undefined;
 const host = resolveHost();
 
@@ -38,59 +40,21 @@ try {
   process.exit(1);
 }
 
-async function importEve(relPath) {
-  return import(pathToFileURL(join(EVE_DIST, relPath)).href);
-}
-
-const [
-  { EveTUIRunner },
-  { createPromptCommandHandler },
-  { promptCommandsFor },
-  { formatRemoteAuthChallengeMessage },
-  { toErrorMessage },
-  { isVercelAuthChallenge },
-  { TerminalRenderer },
-] = await Promise.all([
-  import(pathToFileURL(join(EVE_TUI, "runner.js")).href),
-  import(pathToFileURL(join(EVE_TUI, "prompt-command-handler.js")).href),
-  import(pathToFileURL(join(EVE_TUI, "prompt-commands.js")).href),
-  import(pathToFileURL(join(EVE_TUI, "remote-auth-result.js")).href),
-  importEve("shared/errors.js"),
-  importEve("services/dev-client/vercel-auth-error.js"),
-  import(pathToFileURL(join(EVE_TUI, "terminal-renderer.js")).href),
-]);
-
-const target = {
-  kind: "remote",
-  serverUrl: host,
-  workspaceRoot: process.cwd(),
-};
-
-const renderer = new TerminalRenderer({ availablePromptCommands: promptCommandsFor("remote") });
-
 function fail(message) {
-  try {
-    panel(renderer).renderLine(message, "error");
-  } catch {
-    console.error(`\n  ${message}\n`);
-  }
+  console.error(`\n  ${message}\n`);
   process.exit(1);
 }
 
 async function ensureReachable() {
-  const ui = panel(renderer);
-  ui.begin("neagen", "pulse");
-  ui.renderLine(`Connecting to ${host}…`, "info");
+  process.stdout.write(`Connecting to ${host}...\n`);
   try {
     await probeHost(host);
-    ui.renderLine("Agent online.", "success");
+    process.stdout.write("Agent online.\n");
   } catch (e) {
-    ui.renderLine(`Can't reach ${host} (${e.message}).`, "error");
-    ui.renderLine("Check your connection, or set NEAGEN_HOST to your server.", "info");
-    ui.end({ preserveDiagnostics: true });
+    process.stderr.write(`Can't reach ${host} (${e.message}).\n`);
+    process.stderr.write("Check your connection, or set NEAGEN_HOST to your server.\n");
     process.exit(1);
   }
-  ui.end({ preserveDiagnostics: false });
 }
 
 async function ensureAuthenticated() {
@@ -101,7 +65,7 @@ async function ensureAuthenticated() {
     clearCreds(profile);
     token = null;
   }
-  token = await runDeviceGrantLogin({ host, profile, renderer });
+  token = await runDeviceGrantLogin({ host, profile });
   const me = await resolveIdentity(host, token);
   if (!me) {
     clearCreds(profile);
@@ -110,6 +74,119 @@ async function ensureAuthenticated() {
   return { token, me };
 }
 
+function formatModel(model) {
+  if (!model) return "unknown";
+  const label = model.providerLabel && model.name ? `${model.providerLabel} ${model.name}` : model.id;
+  return `${label} (${model.id})`;
+}
+
+function modelAliases(input) {
+  const value = input.trim();
+  const lower = value.toLowerCase();
+  if (lower === "deepseek" || lower === "flash") return "deepseek/deepseek-v4-flash";
+  if (lower === "sonnet" || lower === "claude" || lower === "claude-sonnet") {
+    return "anthropic/claude-sonnet-4.6";
+  }
+  return value;
+}
+
+async function runModelPicker(rl, token) {
+  let selection;
+  let models;
+  try {
+    [selection, models] = await Promise.all([
+      getSelectedModel(host, token),
+      listModels(host, token),
+    ]);
+  } catch (e) {
+    process.stderr.write(`! ${e?.message ?? e}\n`);
+    return;
+  }
+
+  const activeId = selection?.activeModel?.id;
+  const chosen = await pickModel(rl, models, activeId);
+  if (!chosen) {
+    process.stdout.write(`${dim("(no change)")}\n`);
+    return;
+  }
+  if (chosen.id === activeId) {
+    process.stdout.write(`${dim(`already using ${formatModel(chosen)}`)}\n`);
+    return;
+  }
+
+  try {
+    const updated = await selectModel(host, token, chosen.id);
+    process.stdout.write(`Switched model to ${bold(formatModel(updated.activeModel))}.\n`);
+  } catch (e) {
+    process.stderr.write(`! ${e?.message ?? e}\n`);
+  }
+}
+
+async function switchModelByName(token, raw) {
+  const modelId = modelAliases(raw);
+  const selection = await selectModel(host, token, modelId);
+  process.stdout.write(`Switched model to ${bold(formatModel(selection.activeModel))}.\n`);
+}
+
+async function handleModelCommand(rl, token, raw) {
+  const arg = raw.trim();
+  if (!arg) {
+    await runModelPicker(rl, token);
+    return;
+  }
+  await switchModelByName(token, arg);
+}
+
+function printHelp() {
+  process.stdout.write([...slashHelpLines(), ""].join("\n"));
+}
+
+function normalizeSlashInput(input) {
+  if (input === "/quit") return "/exit";
+  return input;
+}
+
+async function askApproval(rl, request) {
+  const tool = requestToolName(request);
+  const details = formatRequestDetails(request);
+  const answer = (await rl.question(
+    `\nApprove ${tool}${details ? ` (${details})` : ""}?\n(y/n) > `,
+  )).trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+
+async function askQuestion(rl, request) {
+  const options = (request.options ?? []).map((option, index) => `${index + 1}. ${option.label}`).join("  ");
+  return rl.question(`\n${request.prompt}\n${options ? `${options}\n` : ""}> `);
+}
+
+function startStatus(label) {
+  if (!process.stdout.isTTY) return { stop() {} };
+
+  let frame = 0;
+  let active = true;
+  const frames = ["", ".", "..", "..."];
+  const render = () => {
+    if (!active) return;
+    cursorTo(process.stdout, 0);
+    process.stdout.write(`${label}${frames[frame % frames.length]}`);
+    clearLine(process.stdout, 1);
+    frame += 1;
+  };
+
+  render();
+  const timer = setInterval(render, 450);
+  return {
+    stop() {
+      if (!active) return;
+      active = false;
+      clearInterval(timer);
+      cursorTo(process.stdout, 0);
+      clearLine(process.stdout, 0);
+    },
+  };
+}
+
 await ensureReachable();
 
 let session;
@@ -122,27 +199,63 @@ try {
 const { me } = session;
 const label = me.displayName ?? "you";
 const ownerId = me.ownerId;
+const token = session.token;
 
-const client = new Client({
-  host,
-  auth: { bearer: () => loadToken(profile) ?? "" },
-  preserveCompletedSessions: true,
+let conversationId;
+const rl = readline.createInterface({
+  input: stdin,
+  output: process.stdout,
+  historySize: 100,
 });
 
-try {
-  await client.health();
-} catch (e) {
-  fail(`Agent unreachable at ${host} (${e.message}).`);
+let chain = Promise.resolve();
+function runExclusive(fn) {
+  const next = chain.then(fn, fn);
+  chain = next.catch(() => {});
+  return next;
+}
+
+async function sendTurn(message) {
+  const status = startStatus("thinking");
+  const result = await sendTransportTurn({
+    host,
+    token,
+    conversationId,
+    message,
+    handlers: {
+      askApproval: (request) => {
+        status.stop();
+        return askApproval(rl, request);
+      },
+      askQuestion: (request) => {
+        status.stop();
+        return askQuestion(rl, request);
+      },
+    },
+  }).finally(() => status.stop());
+  conversationId = result?.conversationId ?? conversationId;
+  return result;
 }
 
 let wake;
 try {
-  const token = loadToken(profile);
   wake = await subscribeInboxWakeAbly(ownerId, (ev) => {
     const what = ev.kind === "message" ? "a message" : `a file (${ev.filename})`;
-    renderer.renderNotice(
-      `📬 New mail — ${what} arrived. Ask me about it (e.g. "what's new?") to fetch it.`,
-    );
+    process.stdout.write(`\nNew mail: ${what} arrived. Fetching it now...\n`);
+    void runExclusive(async () => {
+      const result = await sendWakeSyncTurn({
+        host,
+        token,
+        event: ev,
+        handlers: {
+          askApproval: (request) => askApproval(rl, request),
+          askQuestion: (request) => askQuestion(rl, request),
+        },
+      });
+      process.stdout.write(`\n${summarizeResult(result)}\n\n`);
+    }).catch((e) => {
+      process.stderr.write(`! wake sync failed: ${e?.message ?? e}\n`);
+    });
   }, { host, bearerToken: token });
 } catch {
   /* wake is best-effort */
@@ -158,16 +271,58 @@ const stopWake = async () => {
 process.on("SIGINT", stopWake);
 process.on("exit", () => void wake?.close());
 
-await new EveTUIRunner({
-  name: `neagen (${label})`,
-  session: client.session(),
-  client,
-  serverUrl: host,
-  renderer,
-  promptCommandHandler: createPromptCommandHandler({ target }),
-  availablePromptCommands: promptCommandsFor("remote"),
-  formatTransportError: (error) =>
-    isVercelAuthChallenge(error) ? formatRemoteAuthChallengeMessage(host) : toErrorMessage(error),
-}).run();
+process.stdout.write(`neagen (${label})\n`);
+process.stdout.write("Type a message, / for commands, /model to switch models, /help for the list.\n\n");
+
+async function handleSlash(rl, input) {
+  const normalized = normalizeSlashInput(input);
+
+  if (normalized === "/exit") return true;
+  if (normalized === "/help") {
+    printHelp();
+    return false;
+  }
+  if (normalized === "/new") {
+    conversationId = undefined;
+    process.stdout.write("Started a new conversation.\n");
+    return false;
+  }
+  if (normalized === "/model" || normalized.startsWith("/model ")) {
+    await handleModelCommand(rl, token, normalized.slice("/model".length));
+    return false;
+  }
+
+  process.stdout.write(`${dim(`unknown command: ${input} (try /help)`)}\n`);
+  return false;
+}
+
+try {
+  for (;;) {
+    let line;
+    try {
+      line = await readPromptLine(rl, { prompt: "neagen> ", slashCommands: SLASH_COMMANDS });
+    } catch {
+      break;
+    }
+    if (line === null) break;
+
+    const input = line.trim();
+    if (!input) continue;
+
+    try {
+      if (input.startsWith("/")) {
+        if (await handleSlash(rl, input)) break;
+        continue;
+      }
+
+      const result = await runExclusive(() => sendTurn(line));
+      process.stdout.write(`\n${summarizeResult(result)}\n\n`);
+    } catch (e) {
+      process.stderr.write(`! ${e?.message ?? e}\n`);
+    }
+  }
+} finally {
+  rl.close();
+}
 
 await stopWake();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neagen",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Your personal networking agent, in the terminal. Chat, agent-mail, and files against your Neagen — passkey login, no passwords.",
   "type": "module",
   "bin": {