@vendian/cli 0.0.30 → 0.0.32

package/cli-wrapper.mjs

@@ -1104,10 +1104,10 @@ function reportProgress(onProgress, message) {
 // src/tui.js
 import fs11 from "node:fs";
 import path8 from "node:path";
-import readlinePromises from "node:readline/promises";
+import readline from "node:readline";
 
 // src/version.js
-var CLI_VERSION = true ? "0.0.30" : process.env.npm_package_version || "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.32" : process.env.npm_package_version || "0.0.0-dev";
 
 // src/npm-update.js
 var NPM_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
@@ -1383,10 +1383,6 @@ function serveProcessExitMessage({ stderr = "", code = 0, signal = "" } = {}) {
   }
   return "";
 }
-function serveProcessExitStderrTail(stderr = "", limit = 1200) {
-  const text = String(stderr || "").trim();
-  return text.length > limit ? text.slice(-limit) : text;
-}
 function applyServeEvent(state, event) {
   if (!event || typeof event.type !== "string") {
     return state;
@@ -1678,9 +1674,6 @@ function appendAgentLog(agentLogs, event) {
     [key]: [...existing, normalized.entry].slice(-5e3)
   };
 }
-function agentLogEntries(agentLogs, relativePath) {
-  return (agentLogs || {})[relativePath] || [];
-}
 function mergeAgentLogRecords(agentLogs, records = []) {
   let next = agentLogs || {};
   for (const record of records) {
@@ -1872,36 +1865,6 @@ function serveEventAgentLogEntry(event) {
   }
   return null;
 }
-function agentRuntimeStatus(agent, agentRunState = {}) {
-  const path9 = stringValue(agent?.relativePath || ".");
-  const run2 = (agentRunState || {})[path9];
-  const inventoryStatus = stringValue(agent?.status);
-  if (run2?.status === "running") {
-    return { status: "running", label: "running", run: run2 };
-  }
-  if (run2?.status === "preparing") {
-    return { status: "preparing", label: "preparing", run: run2 };
-  }
-  if (run2?.status === "error" || inventoryStatus === "error") {
-    return { status: "error", label: "error", run: run2 };
-  }
-  if (run2?.status === "disabled" || inventoryStatus === "disabled") {
-    return {
-      status: "disabled",
-      label: "disabled",
-      run: run2,
-      disabledReason: run2?.disabledReason || agent?.disabledReason || "System dependency not met locally",
-      resolutionHints: run2?.resolutionHints || agent?.resolutionHints || []
-    };
-  }
-  if (inventoryStatus === "online") {
-    return { status: run2?.status === "completed" ? "completed" : "ready", label: "ready", run: run2 };
-  }
-  if (run2?.status === "completed") {
-    return { status: "completed", label: "ready", run: run2 };
-  }
-  return { status: inventoryStatus || "unknown", label: inventoryStatus || "unknown", run: run2 };
-}
 function appendError(errors, scope, message) {
   return [...errors, { scope, message: stringValue(message) }].slice(-20);
 }
@@ -2391,288 +2354,152 @@ var ascii = {
 var fig = supportsUnicode ? unicode : ascii;
 
 // src/tui.js
-var term;
-async function loadTerm() {
-  if (term) return;
-  const tk = await import("terminal-kit");
-  term = tk.default.terminal;
-}
-var HEADER_ROWS_BASE = 7;
-var SERVE_CONTENT_ROW = 10;
-function clampListIndex(index, count) {
-  if (!Number.isFinite(count) || count <= 0) return 0;
-  if (!Number.isFinite(index)) return 0;
-  return Math.max(0, Math.min(count - 1, index));
-}
-function centeredWindowStart(selectedIdx, visibleCount, totalCount) {
-  if (visibleCount >= totalCount) return 0;
-  const half = Math.floor(visibleCount / 2);
-  const maxStart = Math.max(0, totalCount - visibleCount);
-  return Math.max(0, Math.min(maxStart, selectedIdx - half));
-}
-function computeServeDashboardViewport({
-  termHeight = 24,
-  agentCount = 0,
-  selectedIdx = 0,
-  activityCount = 0,
-  diagnosticsCount = 0
-} = {}) {
-  const availableRows = Math.max(4, (termHeight || 24) - SERVE_CONTENT_ROW + 1);
-  const clampedSelectedIdx = clampListIndex(selectedIdx, agentCount);
-  const viewport = {
-    selectedIdx: clampedSelectedIdx,
-    showBlankAfterStatus: false,
-    showAgentHeader: agentCount > 0,
-    visibleAgentCount: 0,
-    agentWindowStart: 0,
-    showAgentHint: false,
-    showAgentRange: false,
-    visibleActivityCount: 0,
-    showActivityHeader: false,
-    visibleDiagnosticsCount: 0,
-    showDiagnosticsHeader: false,
-    showInlineErrors: (termHeight || 24) >= 24
-  };
-  let remaining = availableRows;
-  remaining -= 1;
-  remaining -= 1;
-  if (agentCount > 0) {
-    remaining -= 1;
-    viewport.visibleAgentCount = 1;
-    remaining -= 1;
-  } else {
-    remaining -= 1;
-  }
-  if (remaining > 0) {
-    viewport.showBlankAfterStatus = true;
-    remaining -= 1;
-  }
-  if (agentCount > 1 && remaining > 0) {
-    const extraAgentRows = Math.min(agentCount - 1, remaining);
-    viewport.visibleAgentCount += extraAgentRows;
-    remaining -= extraAgentRows;
-  }
-  if (agentCount > 0) {
-    viewport.agentWindowStart = centeredWindowStart(
-      clampedSelectedIdx,
-      viewport.visibleAgentCount,
-      agentCount
-    );
-    viewport.showAgentHint = remaining > 0;
-    if (viewport.showAgentHint) remaining -= 1;
-    viewport.showAgentRange = viewport.visibleAgentCount > 0 && viewport.visibleAgentCount < agentCount;
-  }
-  if (activityCount > 0 && remaining > 1) {
-    viewport.showActivityHeader = true;
-    remaining -= 1;
-    viewport.visibleActivityCount = Math.min(activityCount, remaining);
-    remaining -= viewport.visibleActivityCount;
-  }
-  if (diagnosticsCount > 0 && remaining > 1) {
-    viewport.showDiagnosticsHeader = true;
-    remaining -= 1;
-    viewport.visibleDiagnosticsCount = Math.min(diagnosticsCount, remaining);
-  }
-  return viewport;
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  gray: "\x1B[90m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[94m"
+};
+function colorize(code, text) {
+  return process.stdout.isTTY ? `${code}${String(text)}${ANSI.reset}` : String(text);
+}
+var col = {
+  bold: (t) => colorize(ANSI.bold, t),
+  gray: (t) => colorize(ANSI.gray, t),
+  cyan: (t) => colorize(ANSI.cyan, t),
+  green: (t) => colorize(ANSI.green, t),
+  yellow: (t) => colorize(ANSI.yellow, t),
+  red: (t) => colorize(ANSI.red, t),
+  blue: (t) => colorize(ANSI.blue, t)
+};
+function print(line = "") {
+  process.stdout.write(`${line}
+`);
 }
-function stopSignalForAttempt(attempt = 0) {
-  if (!Number.isFinite(attempt) || attempt <= 0) return "SIGINT";
-  if (attempt === 1) return "SIGTERM";
-  return "SIGKILL";
+function hr(w) {
+  return "\u2500".repeat(Math.min(w || 60, process.stdout.columns || 80));
 }
-async function runTui({
-  env = process.env,
-  platform = process.platform,
-  output = process.stdout
-} = {}) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    output.write(`${helpText()}
-`);
-    return;
-  }
-  await refreshInteractiveManagedRuntime({ env, platform, output });
-  await loadTerm();
-  term.fullscreen(true);
-  setCursorVisible(false);
-  term.grabInput({ mouse: "motion" });
-  const cleanup = () => {
-    try {
-      term.grabInput(false);
-      setCursorVisible(true);
-      term.fullscreen(false);
-    } catch {
-    }
-  };
-  process.once("exit", cleanup);
-  try {
-    await mainLoop({ env, platform });
-  } finally {
-    process.off("exit", cleanup);
-    cleanup();
-  }
+function setCursorVisible(visible) {
+  if (!process.stdout.isTTY) return;
+  process.stdout.write(visible ? "\x1B[?25h" : "\x1B[?25l");
 }
-async function refreshInteractiveManagedRuntime({
-  env = process.env,
-  platform = process.platform,
-  output = process.stderr,
-  refreshPackageAccess = refreshPackageAccessFromCloudAuth,
-  autoUpdate = maybeAutoUpdateManagedEnv
-} = {}) {
-  if (env.VENDIAN_SKIP_AUTO_UPDATE === "1") return false;
+function makeRl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+}
+async function ask(question, defaultValue = "") {
+  const rl = makeRl();
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  return new Promise((resolve) => {
+    rl.question(`  ${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+async function pressEnterToContinue({ grabActive = true } = {}) {
+  return new Promise((resolve) => {
+    const rl = makeRl();
+    process.stdout.write("\n  Press Enter to continue\u2026 ");
+    rl.once("line", () => {
+      rl.close();
+      resolve();
+    });
+    rl.once("close", resolve);
+  });
+}
+async function withOutputMode(label, fn) {
+  setCursorVisible(true);
+  print("");
+  print(`  ${label}`);
+  print(`  ${"\u2500".repeat(50)}`);
+  print("");
   try {
-    await refreshPackageAccess({ env, platform });
+    await fn();
   } catch (error) {
-    output.write(`[vendian] Package access refresh failed; continuing. ${errMsg(error)}
-`);
-  }
-  return autoUpdate({ env, platform, force: true });
-}
-async function mainLoop({ env, platform }) {
-  let screen = "home";
-  while (true) {
-    let next;
-    switch (screen) {
-      case "run":
-        next = await showRun({ env, platform });
-        break;
-      case "home":
-        next = await showHome({ env, platform });
-        break;
-      case "connect":
-        next = await showConnect({ env, platform });
-        break;
-      case "create":
-        next = await showCreate({ env, platform });
-        break;
-      case "serve":
-        next = await showServe({ env, platform });
-        break;
-      case "commands":
-        next = await showCommands();
-        break;
-      default:
-        next = "exit";
-    }
-    if (!next || next === "exit") break;
-    screen = next;
+    print(`
+  Something went wrong: ${errMsg(error)}`);
   }
+  await pressEnterToContinue({ grabActive: false });
 }
-function drawHeader({ env, platform, serveState = null } = {}) {
+function printHeader({ env, platform } = {}) {
   const active = activeCloudAuthStatus({ env, platform });
-  const runtime = runtimeSummary({ env, platform });
-  const pkg = packageAccessSummary({ env, platform });
-  const w = Math.min(term.width || 80, 90);
-  const inner = w - 2;
-  const ver = `v${CLI_VERSION}`;
-  const title = `  ${fig.arrowUp} VENDIAN`;
-  const gap = Math.max(1, inner - title.length - ver.length - 2);
-  term.moveTo(1, 1);
-  term.gray(`\u256D${"\u2500".repeat(inner)}\u256E
-`);
-  term.gray("\u2502");
-  term.cyan.bold(title);
-  term(" ".repeat(gap));
-  term.gray(`${ver}  \u2502
-`);
-  term.gray(`\u251C${"\u2500".repeat(inner)}\u2524
-`);
-  const accountVal = active.authenticated ? `${active.email || "Signed in"} \u2014 ${envLabel(active.apiUrl)}` : "Not signed in \u2014 choose  Sign in  from the menu";
-  drawHdrRow(inner, active.authenticated ? "ok" : "warn", "Account", accountVal);
-  const systemOk = runtime.installed && pkg.configured;
-  const systemVal = systemOk ? "Ready to run agents" : !runtime.installed ? "Not set up yet \u2014 choose  Sign in  from the menu" : "Package access missing \u2014 choose  Sign in  from the menu";
-  drawHdrRow(inner, systemOk ? "ok" : "warn", "System", systemVal);
-  if (serveState !== null) {
-    const st = serveState.stopped ? "err" : serveState.connected ? "ok" : "warn";
-    const val = serveState.stopped ? "Stopped" : serveState.connected ? `Running \u2014 ${clip(serveState.daemonId || "", 16)}` : clip(serveState.activity || "Starting up\u2026", 52);
-    drawHdrRow(inner, st, "Agents", val);
-  }
-  term.gray(`\u2570${"\u2500".repeat(inner)}\u256F
-`);
-}
-function drawHdrRow(inner, status, label, value) {
-  const maxVal = Math.max(0, inner - 18);
-  const clipped = clip(value, maxVal);
-  const pad = Math.max(0, inner - 15 - clipped.length - 3);
-  term.gray("\u2502  ");
-  if (status === "ok") term.green("\u25CF");
-  else if (status === "warn") term.yellow("\u25CF");
-  else term.red("\u25CF");
-  term(" ");
-  term.bold(label.padEnd(10));
-  term(clipped);
-  term(" ".repeat(pad));
-  term.gray("  \u2502\n");
+  const acct = active.authenticated ? `${active.email || "signed in"} @ ${envLabel(active.apiUrl)}` : col.yellow("not signed in");
+  const W = Math.min(process.stdout.columns || 80, 100);
+  print(col.gray(hr(W)));
+  print(`  ${col.cyan(col.bold("\u2191 VENDIAN"))}  ${col.gray(`v${CLI_VERSION}`)}  ${col.gray("\u2502")}  ${acct}`);
+  print(col.gray(hr(W)));
 }
 function envLabel(apiUrl) {
   if (!apiUrl) return "";
-  if (apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) return "Local";
-  if (apiUrl.includes("staging")) return "Staging";
-  if (apiUrl.includes(".dev.")) return "Development";
-  if (apiUrl.includes("vendian.ai") && !apiUrl.includes(".")) return "Production";
+  if (apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) return "local";
+  if (apiUrl.includes("staging")) return "staging";
+  if (apiUrl.includes(".dev.")) return "dev";
   return clip(apiUrl.replace(/^https?:\/\//, ""), 30);
 }
 var HOME_ACTIONS = [
-  { value: "serve", label: "Run my agents", desc: "Start your agents and keep them running" },
-  { value: "connect", label: "Sign in", desc: "Connect to a different account or environment" },
+  { value: "serve", label: "Serve my agents", desc: "Start agents and stream their logs" },
+  { value: "connect", label: "Login / Switch", desc: "Sign in or switch to a different environment" },
   { value: "create", label: "Create Agent", desc: "Build a new agent from a template" },
-  { value: "commands", label: "Commands", desc: "Show all available CLI commands" },
-  { value: "run", label: "Run once", desc: "Execute one local agent immediately" },
+  { value: "run", label: "Run once", desc: "Execute one agent immediately" },
+  { value: "commands", label: "Commands", desc: "Show all CLI commands" },
   { value: "exit", label: "Exit", desc: "" }
 ];
 async function showHome({ env, platform }) {
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.gray("  What would you like to do?\n\n");
-  const items = HOME_ACTIONS.map(
-    (a) => a.desc ? `${a.label.padEnd(20)}  ${a.desc}` : a.label
-  );
-  const resp = await term.singleColumnMenu(items, {
-    cancelable: false,
-    style: term.gray,
-    selectedStyle: term.bgCyan.black.bold,
-    leftPadding: "    ",
-    selectedLeftPadding: "  \u203A "
-  }).promise;
-  if (resp.canceled) return "exit";
-  return HOME_ACTIONS[resp.selectedIndex]?.value ?? "exit";
+  print("");
+  printHeader({ env, platform });
+  print("");
+  print(col.bold("  What would you like to do?"));
+  print("");
+  HOME_ACTIONS.forEach((action, i) => {
+    const desc = action.desc ? col.gray(`  \u2014 ${action.desc}`) : "";
+    print(`  ${col.blue(String(i + 1))}  ${action.label.padEnd(22)}${desc}`);
+  });
+  print("");
+  const ans = await ask("Choose a number");
+  const n = parseInt(ans, 10);
+  if (!Number.isFinite(n) || n < 1 || n > HOME_ACTIONS.length) return "home";
+  return HOME_ACTIONS[n - 1].value;
 }
 var ENDPOINTS = [
   { key: "prod", label: "Production", subtitle: "Recommended for live use" },
   { key: "staging", label: "Staging", subtitle: "Pre-release testing" },
   { key: "dev", label: "Development", subtitle: "Developer preview" },
-  { key: "local", label: "Local (your computer)", subtitle: "Runs on localhost:3000" }
+  { key: "local", label: "Local (localhost:3000)", subtitle: "Local backend" }
 ];
 async function showConnect({ env, platform }) {
   while (true) {
-    term.clear();
-    drawHeader({ env, platform });
-    term("\n");
-    term.bold("  Sign in to your account:\n\n");
+    print("");
+    printHeader({ env, platform });
+    print("");
+    print(col.bold("  Login / Switch environment:"));
+    print("");
     const rows = endpointRows({ env, platform });
     const items = [
       ...ENDPOINTS.map((ep2) => {
         const row = rows.find((r) => r.key === ep2.key);
-        const badge = row?.active ? "  \u25CF signed in (active)" : row?.status === "signed in" ? "  \u25CB signed in" : `  \u2014 ${ep2.subtitle}`;
+        const badge = row?.active ? col.green(" \u25CF active") : row?.status === "signed in" ? col.cyan(" \u25CB signed in") : col.gray(` \u2014 ${ep2.subtitle}`);
         return `${ep2.label.padEnd(26)}${badge}`;
       }),
       "Custom server URL\u2026",
-      "\u2190 Back"
+      col.gray("Back")
     ];
-    const resp = await term.singleColumnMenu(items, {
-      cancelable: true,
-      style: term.gray,
-      selectedStyle: term.bgCyan.black.bold,
-      leftPadding: "    ",
-      selectedLeftPadding: "  \u203A "
-    }).promise;
-    if (resp.canceled || resp.selectedIndex === items.length - 1) return "home";
-    if (resp.selectedIndex === items.length - 2) {
+    items.forEach((item, i) => print(`  ${col.blue(String(i + 1))}  ${item}`));
+    print("");
+    const ans = await ask("Choose a number, or 0 to go back");
+    const n = parseInt(ans, 10);
+    if (n === 0 || isNaN(n)) return "home";
+    if (n === items.length) return "home";
+    if (n < 1 || n > items.length) continue;
+    if (n === items.length - 1) {
       await connectCustomUrl({ env, platform });
       continue;
     }
-    const ep = ENDPOINTS[resp.selectedIndex];
-    term("\n");
+    const ep = ENDPOINTS[n - 1];
+    print("");
     const outcome = await connectEndpointInteractive({ backend: ep.key, label: ep.label, env, platform });
     if (outcome.promptedInTui) {
       await pressEnterToContinue();
@@ -2680,74 +2507,18 @@ async function showConnect({ env, platform }) {
   }
 }
 async function connectCustomUrl({ env, platform }) {
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold("  Enter your server URL:\n\n");
-  term.gray("  URL: ");
-  const url = await term.inputField({ cancelable: true, style: term.cyan, default: "https://" }).promise;
-  if (!url) return;
-  term("\n\n");
-  term.gray("  Connecting\u2026\n");
-  const outcome = await connectEndpointInteractive({ apiUrl: url, label: url, env, platform, successLabel: "Connected successfully" });
+  print("");
+  print(col.bold("  Enter your server URL:"));
+  print("");
+  const url = await ask("URL", "https://");
+  if (!url || url === "https://") return;
+  print("");
+  print(col.gray("  Connecting\u2026"));
+  const outcome = await connectEndpointInteractive({ apiUrl: url, label: url, env, platform });
   if (outcome.promptedInTui) {
     await pressEnterToContinue();
   }
 }
-async function showCreate({ env, platform }) {
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold("  Create a new agent\n\n");
-  term.gray("  Agent name: ");
-  const name = await term.inputField({ cancelable: true, style: term.cyan }).promise;
-  if (!name?.trim()) return "home";
-  term("\n");
-  term.gray("  Save it in folder: ");
-  const dir = await term.inputField({ cancelable: true, style: term.cyan, default: "./agents" }).promise;
-  if (dir === null) return "home";
-  term("\n");
-  await withOutputMode(
-    `Creating agent: ${name.trim()}`,
-    () => forwardToPythonVendian(["create", name.trim(), "--output-dir", dir || "./agents"], { env, platform })
-  );
-  return "home";
-}
-async function showRun({ env, platform }) {
-  const candidates = findAgentDirectoryCandidates();
-  const picked = await pickSingleAgentToRun({ env, platform, candidates });
-  if (!picked) return "home";
-  const workspace = await chooseCloudWorkspace({
-    env,
-    platform,
-    loadingTitle: "  Getting ready to run this agent\u2026",
-    pickerTitle: "  Which project should own this run?\n\n"
-  });
-  if (!workspace) return "home";
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold(`  Run ${picked.displayName}
-
-`);
-  term.gray(`  Agent: ${picked.path}
-`);
-  term.gray(`  Project: ${workspace.label}
-
-`);
-  term.gray("  Input JSON: ");
-  const inputJson = await term.inputField({ cancelable: true, style: term.cyan, default: "{}" }).promise;
-  if (inputJson === null) return "home";
-  await withOutputMode(
-    `Running ${picked.displayName}`,
-    () => forwardToPythonVendian(buildLocalRunArgs({
-      agentPath: picked.path,
-      collectionId: workspace.id,
-      inputJson: inputJson || "{}"
-    }), { env, platform })
-  );
-  return "home";
-}
 var COMMAND_GROUPS = [
   { section: "Getting started", commands: [
     { cmd: "vendian login", desc: "Sign in and set up your computer" },
@@ -2756,13 +2527,12 @@ var COMMAND_GROUPS = [
   { section: "Building agents", commands: [
     { cmd: 'vendian create "My Agent" --output-dir .', desc: "Create a new agent" },
     { cmd: "vendian validate ./agents/my-agent", desc: "Check an agent for errors" },
-    { cmd: "vendian test ./agents/my-agent --dry-run", desc: "Test an agent without running it" },
     { cmd: "vendian models", desc: "List available AI models" }
   ] },
   { section: "Running agents", commands: [
-    { cmd: "vendian cloud local run --collection-id ID --path . --input-json '{}'", desc: "Run one local agent once" },
-    { cmd: "vendian cloud local serve --agents-dir .", desc: "Start agents (advanced mode)" },
-    { cmd: "vendian login --backend staging", desc: "Sign in to staging environment" }
+    { cmd: "vendian cloud local run --collection-id ID --path . --input-json '{}'", desc: "Run one agent" },
+    { cmd: "vendian cloud local serve --agents-dir .", desc: "Start agents" },
+    { cmd: "vendian login --backend staging", desc: "Sign in to staging" }
   ] },
   { section: "Maintenance", commands: [
     { cmd: "vendian doctor", desc: "Check if everything is set up" },
@@ -2770,89 +2540,52 @@ var COMMAND_GROUPS = [
   ] }
 ];
 async function showCommands() {
-  term.clear();
-  const w = Math.min(term.width || 80, 90);
-  term.gray(`\u256D${"\u2500".repeat(w - 2)}\u256E
-`);
-  term.gray("\u2502");
-  term.cyan.bold(`  ${fig.arrowUp} VENDIAN  All Commands`);
-  term(" ".repeat(Math.max(0, w - 26)));
-  term.gray("\u2502\n");
-  term.gray(`\u2570${"\u2500".repeat(w - 2)}\u256F
-
-`);
+  print("");
+  print(col.bold(`  \u2191 VENDIAN v${CLI_VERSION}  \u2014  All Commands`));
+  print("");
   for (const g of COMMAND_GROUPS) {
-    term.brightBlue.bold(`  ${g.section}
-`);
+    print(col.blue(col.bold(`  ${g.section}`)));
     for (const item of g.commands) {
-      term.gray("    ");
-      term.cyan(item.cmd.padEnd(46));
-      term.gray(`${item.desc}
-`);
+      print(`    ${col.cyan(item.cmd.padEnd(52))}  ${col.gray(item.desc)}`);
     }
-    term("\n");
+    print("");
   }
-  term.gray("  Press any key to go back\u2026");
-  await waitForKey();
+  await pressEnterToContinue();
   return "home";
 }
-async function showServe({ env, platform }) {
-  const candidates = findAgentDirectoryCandidates();
-  const picked = await pickAgentsToRun({ env, platform, candidates });
-  if (!picked) return "home";
-  const { agentsDir } = picked;
-  const workspace = await chooseCloudWorkspace({
-    env,
-    platform,
-    loadingTitle: "  Getting ready to run your agents\u2026",
-    pickerTitle: "  Which project do you want to run?\n\n"
-  });
-  if (!workspace) return "home";
-  return await runServeDashboard({ env, platform, agentsDir, collectionId: workspace.id });
-}
 async function pickAgentsToRun({ env, platform, candidates }) {
   if (candidates.length === 0) {
-    term.clear();
-    drawHeader({ env, platform });
-    term("\n");
-    term.bold("  I couldn't find any agents on your computer.\n\n");
-    term.gray("  Enter the path to your agents folder:\n\n");
-    term.gray("  Folder: ");
-    const input = await term.inputField({ cancelable: true, style: term.cyan, default: "./agents" }).promise;
-    if (input === null) return null;
-    return { agentsDir: input || "./agents" };
+    print("");
+    print(col.yellow("  Couldn't find any agents. Enter your agents folder path:"));
+    const input = await ask("Folder", "./agents");
+    return input ? { agentsDir: input } : null;
   }
   if (candidates.length === 1 && candidates[0].agentCount === 1) {
     return { agentsDir: candidates[0].path };
   }
   if (candidates.length === 1) {
-    return await pickAgentsFromFolder({ env, platform, candidate: candidates[0] });
+    return pickAgentsFromFolder({ env, platform, candidate: candidates[0] });
   }
-  return await pickProject({ env, platform, candidates });
+  return pickProject({ env, platform, candidates });
 }
 async function pickProject({ env, platform, candidates }) {
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold("  Which project do you want to run?\n\n");
-  const items = [
-    ...candidates.map((c) => {
-      const projectName = readManifestName(c.absolutePath) || friendlyName(path8.basename(c.absolutePath) || c.path);
-      return `${projectName.padEnd(32)}  ${c.agentCount} ${c.agentCount === 1 ? "agent" : "agents"}`;
-    }),
-    "\u2190 Back"
-  ];
-  const resp = await term.singleColumnMenu(items, {
-    cancelable: true,
-    style: term.gray,
-    selectedStyle: term.bgCyan.black.bold,
-    leftPadding: "    ",
-    selectedLeftPadding: "  \u203A "
-  }).promise;
-  if (resp.canceled || resp.selectedIndex === items.length - 1) return null;
-  const chosen = candidates[resp.selectedIndex];
+  print("");
+  printHeader({ env, platform });
+  print("");
+  print(col.bold("  Which project do you want to run?"));
+  print("");
+  candidates.forEach((candidate, i) => {
+    const name = readManifestName(candidate.absolutePath) || friendlyName(path8.basename(candidate.absolutePath) || candidate.path);
+    print(`  ${col.blue(String(i + 1))}  ${name.padEnd(32)}  ${col.gray(`${candidate.agentCount} agent${candidate.agentCount === 1 ? "" : "s"}`)}`);
+  });
+  print(`  ${col.gray("0  Back")}`);
+  print("");
+  const ans = await ask("Choose");
+  const n = parseInt(ans, 10);
+  if (n === 0 || isNaN(n) || n > candidates.length) return null;
+  const chosen = candidates[n - 1];
   if (chosen.agentCount <= 1) return { agentsDir: chosen.path };
-  return await pickAgentsFromFolder({ env, platform, candidate: chosen });
+  return pickAgentsFromFolder({ env, platform, candidate: chosen });
 }
 async function pickAgentsFromFolder({ env, platform, candidate }) {
   const folders = findAgentFolders(candidate.absolutePath);
@@ -2861,39 +2594,28 @@ async function pickAgentsFromFolder({ env, platform, candidate }) {
     ...f,
     displayName: readManifestName(f.absolutePath) || friendlyName(f.name || path8.basename(f.path))
   }));
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold("  Which agents do you want to start?\n\n");
-  term.gray("  Tip: running fewer agents uses less memory and starts faster.\n\n");
-  const items = [
-    `Run all ${folders.length} agents`,
-    ...named.map((f) => f.displayName),
-    "\u2190 Back"
-  ];
-  const resp = await term.singleColumnMenu(items, {
-    cancelable: true,
-    style: term.gray,
-    selectedStyle: term.bgCyan.black.bold,
-    leftPadding: "    ",
-    selectedLeftPadding: "  \u203A "
-  }).promise;
-  if (resp.canceled || resp.selectedIndex === items.length - 1) return null;
-  if (resp.selectedIndex === 0) return { agentsDir: candidate.path };
-  return { agentsDir: named[resp.selectedIndex - 1].path };
+  print("");
+  printHeader({ env, platform });
+  print("");
+  print(col.bold("  Which agents do you want to start?"));
+  print("");
+  print(`  ${col.blue("1")}  Run all ${folders.length} agents`);
+  named.forEach((f, i) => print(`  ${col.blue(String(i + 2))}  ${f.displayName}`));
+  print(`  ${col.gray("0  Back")}`);
+  print("");
+  const ans = await ask("Choose");
+  const n = parseInt(ans, 10);
+  if (n === 0 || isNaN(n) || n > named.length + 1) return null;
+  if (n === 1) return { agentsDir: candidate.path };
+  return { agentsDir: named[n - 2].path };
 }
 async function pickSingleAgentToRun({ env, platform, candidates }) {
   if (candidates.length === 0) {
-    term.clear();
-    drawHeader({ env, platform });
-    term("\n");
-    term.bold("  I couldn't find any agents on your computer.\n\n");
-    term.gray("  Enter the path to one agent folder:\n\n");
-    term.gray("  Folder: ");
-    const input = await term.inputField({ cancelable: true, style: term.cyan, default: "./agents/my-agent" }).promise;
-    if (input === null) return null;
-    const agentPath = input || "./agents/my-agent";
-    return { path: agentPath, displayName: friendlyName(path8.basename(agentPath) || "Agent") };
+    print("");
+    print(col.yellow("  Couldn't find any agents."));
+    const input = await ask("Agent folder", "./agents/my-agent");
+    if (!input) return null;
+    return { path: input, displayName: friendlyName(path8.basename(input) || "Agent") };
   }
   const agents = candidates.flatMap((candidate) => {
     const folders = findAgentFolders(candidate.absolutePath);
@@ -2909,32 +2631,24 @@ async function pickSingleAgentToRun({ env, platform, candidates }) {
     }];
   });
   if (agents.length === 1) return agents[0];
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold("  Which agent do you want to run now?\n\n");
-  const items = [...agents.map((agent) => `${agent.displayName.padEnd(32)}  ${agent.path}`), "\u2190 Back"];
-  const resp = await term.singleColumnMenu(items, {
-    cancelable: true,
-    style: term.gray,
-    selectedStyle: term.bgCyan.black.bold,
-    leftPadding: "    ",
-    selectedLeftPadding: "  \u203A "
-  }).promise;
-  if (resp.canceled || resp.selectedIndex === items.length - 1) return null;
-  return agents[resp.selectedIndex];
-}
-async function chooseCloudWorkspace({
-  env,
-  platform,
-  loadingTitle,
-  pickerTitle
-} = {}) {
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold(`${loadingTitle}
-
+  print("");
+  printHeader({ env, platform });
+  print("");
+  print(col.bold("  Which agent do you want to run?"));
+  print("");
+  agents.forEach((agent, i) => {
+    print(`  ${col.blue(String(i + 1))}  ${agent.displayName.padEnd(32)}  ${col.gray(agent.path)}`);
+  });
+  print(`  ${col.gray("0  Back")}`);
+  print("");
+  const ans = await ask("Choose");
+  const n = parseInt(ans, 10);
+  if (n === 0 || isNaN(n) || n > agents.length) return null;
+  return agents[n - 1];
+}
+async function chooseCloudWorkspace({ env, platform, loadingTitle, pickerTitle } = {}) {
+  print("");
+  process.stdout.write(`  ${col.gray(loadingTitle || "Loading workspaces\u2026")}
 `);
   let wsResult;
   try {
@@ -2942,279 +2656,214 @@ async function chooseCloudWorkspace({
       env,
       platform,
       onProgress: (msg) => {
-        term.moveTo(1, HEADER_ROWS_BASE + 3);
-        term.eraseLine();
-        term.gray(`  ${clip(msg, 60)}
-`);
+        process.stdout.write(`\r  ${col.gray(clip(msg, 60))}            `);
       }
     });
+    process.stdout.write("\r" + " ".repeat(70) + "\r");
   } catch (error) {
-    term.red(`
-  Couldn't connect to the server: ${errMsg(error)}
-`);
-    term.gray("  Make sure you are signed in (choose Sign in from the main menu).\n");
+    process.stdout.write("\r" + " ".repeat(70) + "\r");
+    print(col.red(`
+  Couldn't connect: ${errMsg(error)}`));
+    print(col.gray("  Make sure you are signed in (choose Login / Switch from the menu)."));
     await pressEnterToContinue({ grabActive: false });
     return null;
   }
   if (!wsResult.ok) {
-    term.red(`
-  ${fig.cross} ${wsResult.error}
-`);
+    print(col.red(`
+  ${fig.cross} ${wsResult.error}`));
     await pressEnterToContinue({ grabActive: false });
     return null;
   }
-  if (wsResult.workspaces.length <= 1) {
-    const workspace2 = wsResult.workspaces[0];
-    return workspace2 ? { id: workspace2.id || "", label: workspaceLabel(workspace2) } : null;
-  }
-  term.clear();
-  drawHeader({ env, platform });
-  term("\n");
-  term.bold(pickerTitle);
-  const wsItems = [...wsResult.workspaces.map((w) => workspaceLabel(w)), "\u2190 Back"];
-  const wsResp = await term.singleColumnMenu(wsItems, {
-    cancelable: true,
-    style: term.gray,
-    selectedStyle: term.bgCyan.black.bold,
-    leftPadding: "    ",
-    selectedLeftPadding: "  \u203A "
-  }).promise;
-  if (wsResp.canceled || wsResp.selectedIndex === wsItems.length - 1) return null;
-  const workspace = wsResult.workspaces[wsResp.selectedIndex];
-  return { id: workspace?.id || "", label: workspaceLabel(workspace) };
-}
-async function runServeDashboard({ env, platform, agentsDir, collectionId }) {
+  if (wsResult.workspaces.length === 0) return null;
+  if (wsResult.workspaces.length === 1) {
+    const ws2 = wsResult.workspaces[0];
+    return { id: ws2.id || "", label: workspaceLabel(ws2) };
+  }
+  print("");
+  print(col.bold(`  ${pickerTitle || "Choose a workspace:"}`));
+  print("");
+  wsResult.workspaces.forEach((ws2, i) => {
+    print(`  ${col.blue(String(i + 1))}  ${workspaceLabel(ws2)}`);
+  });
+  print(`  ${col.gray("0  Back")}`);
+  print("");
+  const ans = await ask("Choose");
+  const n = parseInt(ans, 10);
+  if (n === 0 || isNaN(n) || n > wsResult.workspaces.length) return null;
+  const ws = wsResult.workspaces[n - 1];
+  return { id: ws.id || "", label: workspaceLabel(ws) };
+}
+async function showCreate({ env, platform }) {
+  print("");
+  printHeader({ env, platform });
+  print("");
+  print(col.bold("  Create a new agent"));
+  print("");
+  const name = await ask("Agent name");
+  if (!name?.trim()) return "home";
+  const dir = await ask("Save it in folder", "./agents");
+  await withOutputMode(
+    `Creating agent: ${name.trim()}`,
+    () => forwardToPythonVendian(["create", name.trim(), "--output-dir", dir || "./agents"], { env, platform })
+  );
+  return "home";
+}
+async function showRun({ env, platform }) {
+  const candidates = findAgentDirectoryCandidates();
+  const picked = await pickSingleAgentToRun({ env, platform, candidates });
+  if (!picked) return "home";
+  const workspace = await chooseCloudWorkspace({
+    env,
+    platform,
+    loadingTitle: "Getting ready to run this agent\u2026",
+    pickerTitle: "Which project should own this run?"
+  });
+  if (!workspace) return "home";
+  const inputJson = await ask("Input JSON", "{}");
+  await withOutputMode(
+    `Running ${picked.displayName}`,
+    () => forwardToPythonVendian(buildLocalRunArgs({
+      agentPath: picked.path,
+      collectionId: workspace.id,
+      inputJson: inputJson || "{}"
+    }), { env, platform })
+  );
+  return "home";
+}
+async function showServe({ env, platform }) {
+  const candidates = findAgentDirectoryCandidates();
+  const picked = await pickAgentsToRun({ env, platform, candidates });
+  if (!picked) return "home";
+  const { agentsDir } = picked;
+  const workspace = await chooseCloudWorkspace({
+    env,
+    platform,
+    loadingTitle: "Getting ready to run your agents\u2026",
+    pickerTitle: "Which project do you want to run?"
+  });
+  if (!workspace) return "home";
+  return await runServeDashboard({ env, platform, agentsDir, collectionId: workspace.id, wsLabel: workspace.label });
+}
+async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLabel = "" }) {
   let state = initialServeState();
   let child = null;
-  let startupError = "";
-  let overlayActive = false;
   let ctrlCArmed = false;
   let ctrlCArmTimer = null;
-  let dashboardClosed = false;
-  let exitPromptActive = false;
-  let selectedIdx = 0;
-  let pressedAgentIdx = null;
   let stopRequested = false;
   let stopSignalAttempt = 0;
   let stopTimer = null;
-  const agentRowMap = /* @__PURE__ */ new Map();
-  function agentDisplayList() {
-    return state.agents.map((agent, i) => {
-      const name = agent.manifestName || agent.manifest?.name || friendlyName(agent.relativePath || ".");
-      const rt = agentRuntimeStatus(agent, state.agentRunState);
-      const status = friendlyStatus(rt.status);
-      const path_ = agent.relativePath || ".";
-      const runst = state.agentRunState[path_];
-      const errMsg2 = rt.status === "error" ? runst?.errorMessage || "Something went wrong \u2014 no details available" : null;
-      return { num: i + 1, name, status, errMsg: errMsg2, path: path_ };
-    });
-  }
-  function recentActivityLines(maxLines = 7) {
-    const all = [];
-    for (const [agentPath, entries] of Object.entries(state.agentLogs || {})) {
-      const agent = state.agents.find((a) => (a.relativePath || ".") === agentPath);
-      const name = agent?.manifestName || agent?.manifest?.name || friendlyName(agentPath);
-      for (const e of entries.slice(-30)) all.push({ ...e, _agentName: name });
-    }
-    all.sort((a, b) => (a.timestamp || "").localeCompare(b.timestamp || ""));
-    return all.slice(-maxLines);
-  }
-  function daemonDebugLines(maxLines = 8) {
-    return serveDebugEntries(state.logs, maxLines);
-  }
-  function redraw() {
-    if (dashboardClosed || overlayActive) return;
-    const agents = agentDisplayList();
-    const activity = recentActivityLines();
-    const diagnostics = daemonDebugLines();
-    const viewport = computeServeDashboardViewport({
-      termHeight: term.height || 24,
-      agentCount: agents.length,
-      selectedIdx,
-      activityCount: activity.length,
-      diagnosticsCount: diagnostics.length
-    });
-    selectedIdx = viewport.selectedIdx;
-    drawHeader({ env, platform, serveState: state });
-    term.moveTo(1, SERVE_CONTENT_ROW);
-    term.eraseDisplayBelow();
-    agentRowMap.clear();
-    if (startupError) {
-      term.red(`  ${fig.cross} ${clip(startupError, (term.width || 80) - 6)}
-`);
-    } else if (stopRequested) {
-      term.yellow(`  ${fig.warning} ${clip(state.activity || "Stopping your agents\u2026", (term.width || 80) - 6)}
-`);
-    } else if (state.stopped) {
-      term.yellow(`  ${fig.warning} Your agents have stopped.
+  let dashboardClosed = false;
+  let logStore = null;
+  const W = Math.min(process.stdout.columns || 80, 100);
+  setCursorVisible(false);
+  print("");
+  print(col.gray("\u2550".repeat(W)));
+  print(`  ${col.cyan(col.bold("\u2191 VENDIAN"))}  ${col.bold("Serving agents")}`);
+  print(`  ${col.gray("Dir:")}       ${agentsDir}`);
+  print(`  ${col.gray("Workspace:")} ${wsLabel || collectionId || "\u2014"}`);
+  print(col.gray(hr(W)));
+  print(col.gray("  S stop gracefully  |  ^c ^c exit"));
+  print(col.gray(hr(W)));
+  print("");
+  function ts() {
+    return formatLogTime((/* @__PURE__ */ new Date()).toISOString());
+  }
+  function printRun(agentName, icon, message) {
+    const name = clip(agentName || "agent", 22).padEnd(22);
+    process.stdout.write(`${ts()}  ${col.blue("RUN   ")}  ${name}  ${icon} ${message}
 `);
-    } else if (state.connected) {
-      term.green(`  ${fig.dot} `);
-      term.gray(`${clip(state.activity || "Your agents are running", 55)}
+  }
+  function printAgent(agentName, statusText) {
+    const name = clip(agentName || "agent", 22).padEnd(22);
+    process.stdout.write(`${ts()}  ${col.cyan("AGENT ")}  ${name}  ${statusText}
 `);
-    } else {
-      term.cyan(`  ${fig.dotEmpty} `);
-      term.gray(`${clip(state.activity || "Starting up\u2026", 55)}
+  }
+  function printDaemon(eventType, message) {
+    const evt = clip(String(eventType || "event"), 26).padEnd(26);
+    process.stdout.write(`${ts()}  ${col.gray("DAEMON")}  ${evt}  ${message}
 `);
+  }
+  function onServeEvent(event) {
+    if (!event) return;
+    const type = String(event.type || "");
+    const agentPath = String(event.relativePath || event.path || "");
+    const agentName = agentPath ? friendlyName(path8.basename(agentPath)) || agentPath : "";
+    if (type === "job_started") {
+      printRun(agentName, col.blue("\u25B6"), `Started ${event.jobType || "job"} ${shortId2(event.runId || "")}`);
+      return;
     }
-    if (agents.length > 0) {
-      if (viewport.showBlankAfterStatus) term("\n");
-      term.bold.gray("  Your agents:\n");
-      let lineOffset = SERVE_CONTENT_ROW + 2 + (viewport.showBlankAfterStatus ? 1 : 0);
-      const visibleAgents = agents.slice(
-        viewport.agentWindowStart,
-        viewport.agentWindowStart + viewport.visibleAgentCount
-      );
-      for (const ag of visibleAgents) {
-        const isSelected = ag.num - 1 === selectedIdx;
-        agentRowMap.set(lineOffset, ag.num - 1);
-        const numStr = String(ag.num).padStart(2);
-        const nameStr = clip(ag.name, 28).padEnd(28);
-        const statLine = `  ${numStr}  ${ag.status.icon}  ${nameStr}  ${ag.status.text}`;
-        if (isSelected) term.bgCyan.black.bold(statLine);
-        else {
-          term(`  ${numStr}  `);
-          switch (ag.status.color) {
-            case "green":
-              term.green(ag.status.icon);
-              break;
-            case "brightBlue":
-              term.brightBlue(ag.status.icon);
-              break;
-            case "cyan":
-              term.cyan(ag.status.icon);
-              break;
-            case "yellow":
-              term.yellow(ag.status.icon);
-              break;
-            case "red":
-              term.red(ag.status.icon);
-              break;
-            default:
-              term.gray(ag.status.icon);
-          }
-          term(`  ${nameStr}  `);
-          switch (ag.status.color) {
-            case "green":
-              term.green(ag.status.text);
-              break;
-            case "brightBlue":
-              term.brightBlue(ag.status.text);
-              break;
-            case "cyan":
-              term.cyan(ag.status.text);
-              break;
-            case "yellow":
-              term.yellow(ag.status.text);
-              break;
-            case "red":
-              term.red(ag.status.text);
-              break;
-            default:
-              term.gray(ag.status.text);
-          }
-        }
-        term("\n");
-        lineOffset++;
-        if (viewport.showInlineErrors && isSelected && ag.errMsg) {
-          term.red(`       \u2514\u2500 ${clip(ag.errMsg, (term.width || 80) - 14)}
-`);
-          lineOffset++;
-        }
-      }
-      if (viewport.showAgentRange) {
-        const first = viewport.agentWindowStart + 1;
-        const last = viewport.agentWindowStart + visibleAgents.length;
-        term.gray(`  Showing agents ${first}\u2013${last} of ${agents.length}
-`);
+    if (type === "job_completed") {
+      const ok = event.success !== false;
+      printRun(agentName, ok ? col.green("\u2714") : col.red("\u2716"), ok ? "Completed" : `Failed: ${fmtErr(event.error)}`);
+      return;
+    }
+    if (type === "run_log") {
+      const lvl = String(event.level || "info");
+      const msg = String(event.message || event.eventType || "");
+      if (!msg) return;
+      const isCompletionEvent = event.eventType === "completion";
+      const icon = lvl === "error" ? col.red("\u2716") : isCompletionEvent ? event.success !== false ? col.green("\u2714") : col.red("\u2716") : "\u2014";
+      printRun(agentName || "?", icon, clip(msg, 80));
+      return;
+    }
+    if (type === "error" && agentPath) {
+      printRun(agentName, col.red("\u2716"), `Error: ${fmtErr(event.error) || String(event.code || "unknown")}`);
+      return;
+    }
+    if (type === "agent_prepare_started") {
+      printAgent(agentName, col.gray("Preparing\u2026"));
+      return;
+    }
+    if (type === "agent_prepare_progress") {
+      const msg = String(event.message || event.stage || "Preparing");
+      printAgent(agentName, col.gray(clip(msg, 60)));
+      return;
+    }
+    if (type === "agent_prepare_completed") {
+      if (event.status === "error") {
+        printAgent(agentName, col.red(`\u2716 Setup failed: ${fmtErr(event.error)}`));
+        return;
       }
-      if (viewport.showAgentHint) {
-        term.gray(`  Click an agent or use \u2191\u2193 + Enter to see its activity log
-`);
+      if (event.status === "disabled") {
+        printAgent(agentName, col.yellow(`\u26A0 Disabled: ${event.disabledReason || "deps not met locally"}`));
+        return;
       }
-    } else {
-      if (viewport.showBlankAfterStatus) term("\n");
-      term.gray("  Looking for your agents\u2026\n");
+      printAgent(agentName, col.green("\u2714 Ready"));
+      return;
     }
-    if (viewport.showActivityHeader) {
-      const visibleActivity = activity.slice(-viewport.visibleActivityCount);
-      const divW = Math.min((term.width || 80) - 4, 60);
-      term.gray(`  ${"\u2500".repeat(3)} Recent activity ${"\u2500".repeat(Math.max(0, divW - 18))}
-`);
-      for (const e of visibleActivity) {
-        const t = formatLogTime(e.timestamp);
-        const name = clip(e._agentName || "Agent", 20);
-        const msg = clip(friendlyActivityLine(e), (term.width || 80) - 30);
-        if (e.level === "error" || e.eventType === "completion" && e.success === false) {
-          term.gray(`  ${t}  `);
-          term.red(`${name} \u2014 ${msg}
-`);
-        } else if (e.eventType === "job_completed" && e.success !== false) {
-          term.gray(`  ${t}  `);
-          term.green(`${name} \u2014 ${msg}
-`);
-        } else if (e.eventType === "job_started") {
-          term.gray(`  ${t}  `);
-          term.brightBlue(`${name} \u2014 ${msg}
-`);
-        } else {
-          term.gray(`  ${t}  ${name} \u2014 ${msg}
-`);
-        }
-      }
-    }
-    if (viewport.showDiagnosticsHeader) {
-      const visibleDiagnostics = diagnostics.slice(-viewport.visibleDiagnosticsCount);
-      const divW = Math.min((term.width || 80) - 4, 72);
-      term.gray(`  ${"\u2500".repeat(3)} Daemon diagnostics ${"\u2500".repeat(Math.max(0, divW - 23))}
-`);
-      for (const entry of visibleDiagnostics) {
-        const t = formatLogTime(entry.timestamp);
-        const type = clip(entry.eventType || "event", 24).padEnd(24);
-        const msg = clip(entry.message || "", (term.width || 80) - 38);
-        term.gray(`  ${t}  `);
-        if (entry.level === "error") {
-          term.red(`${type} ${msg}
-`);
-        } else if (entry.level === "warn") {
-          term.yellow(`${type} ${msg}
-`);
-        } else {
-          term.gray(`${type} ${msg}
-`);
+    if (type === "inventory_synced") {
+      const agents = Array.isArray(event.agents) ? event.agents : [];
+      for (const a of agents) {
+        const name = friendlyName(path8.basename(a.relativePath || ".")) || a.manifestName || a.relativePath || "?";
+        if (a.status === "error") {
+          printAgent(name, col.red(`\u2716 Error: ${a.errorMessage || ""}`));
+          continue;
+        }
+        if (a.status === "disabled") {
+          printAgent(name, col.yellow(`\u26A0 Disabled: ${a.disabledReason || ""}`));
+          continue;
+        }
+        if (a.status === "online") {
+          printAgent(name, col.green("\u25CF Online"));
+          continue;
         }
       }
+      return;
     }
-    term("\n");
-    if (ctrlCArmed) {
-      term.yellow.bold("  Press Ctrl+C again to exit.\n");
-    } else if (stopRequested) {
-      term.yellow("  Stopping your agents\u2026");
-      if (stopSignalAttempt > 0) term.gray("  (retrying shutdown)");
-      term("\n");
-    } else {
-      term.gray("  ");
-      term.brightBlue.bold("S");
-      term.gray(" Stop    ");
-      term.brightBlue.bold("^c ^c");
-      term.gray(" Exit\n");
+    const dbgArr = serveDebugEntries([event], 1);
+    if (dbgArr.length > 0) {
+      const dbg = dbgArr[0];
+      const msg = dbg.level === "error" ? col.red(dbg.message) : dbg.level === "warn" ? col.yellow(dbg.message) : col.gray(dbg.message);
+      printDaemon(dbg.eventType, msg);
     }
   }
-  term.clear();
-  drawHeader({ env, platform, serveState: state });
-  term.moveTo(1, SERVE_CONTENT_ROW);
-  term.cyan(`  ${fig.dotEmpty} Getting your agents ready\u2026
-`);
   try {
-    state = { ...state, activity: "Loading previous logs" };
-    const logStore = createServeLogStore({ agentsDir, collectionId, env, platform });
+    logStore = createServeLogStore({ agentsDir, collectionId, env, platform });
     const historicalLogs = logStore.load();
     if (historicalLogs.length > 0) {
       const agentLogs = mergeAgentLogRecords(state.agentLogs, historicalLogs);
       state = { ...state, agentLogs, agentRunState: { ...agentRunStateFromLogs(agentLogs, { includeRunning: false }), ...state.agentRunState } };
     }
-    state = { ...state, activity: "Preparing your agents\u2026" };
-    redraw();
     child = await spawnLocalServeEventStream({
       agentsDir,
       collectionId,
@@ -3222,543 +2871,219 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId }) {
       platform,
       onProgress: (msg) => {
         if (dashboardClosed) return;
-        state = { ...state, activity: msg || "Preparing\u2026" };
-        redraw();
+        process.stdout.write(`\r  ${col.gray(clip(msg || "Preparing\u2026", 70))}          `);
       }
     });
-    state = { ...state, activity: "Connecting to server\u2026" };
-    redraw();
-    attachServeChild(
-      child,
-      (updater) => {
-        if (dashboardClosed) return;
-        state = updater(state);
-        redraw();
-      },
-      ({ message } = {}) => {
-        if (dashboardClosed) return;
-        if (!state.stopped) state = { ...state, stopped: true, activity: message || "Stopped" };
-        redraw();
-      },
-      logStore
-    );
+    process.stdout.write("\r" + " ".repeat(80) + "\r");
+    printDaemon("serve_started", col.gray(`dir=${agentsDir}`));
   } catch (error) {
-    startupError = errMsg(error);
-    redraw();
+    setCursorVisible(true);
+    print(col.red(`  ${fig.cross} Failed to start: ${errMsg(error)}`));
+    await pressEnterToContinue({ grabActive: false });
+    return "home";
   }
   return new Promise((resolve) => {
-    function openAgentLog(idx) {
-      const agents = agentDisplayList();
-      const clampedIdx = clampListIndex(idx, agents.length);
-      if (dashboardClosed || exitPromptActive || agents.length === 0 || idx !== clampedIdx) return;
-      overlayActive = true;
-      const ag = agents[clampedIdx];
-      showAgentLog({ agent: ag, getState: () => state, env, platform }).then(() => {
-        if (dashboardClosed) return;
-        overlayActive = false;
-        term.clear();
-        redraw();
-      });
-    }
-    function clearCtrlCArm() {
-      ctrlCArmed = false;
-      if (ctrlCArmTimer) {
-        clearTimeout(ctrlCArmTimer);
-        ctrlCArmTimer = null;
-      }
-    }
-    function clearStopTimer() {
-      if (stopTimer) {
-        clearTimeout(stopTimer);
-        stopTimer = null;
-      }
+    let removeKeypress = () => {
+    };
+    function finish(next) {
+      if (dashboardClosed) return;
+      dashboardClosed = true;
+      clearTimeout(ctrlCArmTimer);
+      clearTimeout(stopTimer);
+      removeKeypress();
+      setCursorVisible(true);
+      resolve(next);
     }
     function childIsRunning() {
       return Boolean(child) && child.exitCode == null && child.signalCode == null;
     }
     function scheduleStopEscalation() {
-      clearStopTimer();
+      clearTimeout(stopTimer);
       if (!childIsRunning()) return;
       stopTimer = setTimeout(() => {
         if (!stopRequested || dashboardClosed || !childIsRunning()) return;
         stopSignalAttempt += 1;
         const signal = stopSignalForAttempt(stopSignalAttempt);
-        state = {
-          ...state,
-          activity: signal === "SIGTERM" ? "Still stopping your agents\u2026" : "Force stopping your agents\u2026"
-        };
         try {
           child.kill(signal);
         } catch {
         }
-        if (!overlayActive) redraw();
         if (signal !== "SIGKILL") scheduleStopEscalation();
       }, 4e3);
     }
     function requestStop() {
-      if (dashboardClosed) return;
-      if (stopRequested) return;
+      if (dashboardClosed || stopRequested) return;
       if (!childIsRunning()) {
         finish("home");
         return;
       }
       stopRequested = true;
-      stopSignalAttempt = 0;
       state = { ...state, activity: "Stopping your agents\u2026" };
-      clearCtrlCArm();
+      print(col.yellow("\n  Stopping your agents\u2026"));
+      clearTimeout(ctrlCArmTimer);
+      ctrlCArmed = false;
       try {
         child.kill(stopSignalForAttempt(stopSignalAttempt));
       } catch {
       }
       scheduleStopEscalation();
-      if (!overlayActive) redraw();
-    }
-    function detachDashboardHandlers() {
-      term.off("key", handleKey);
-      term.off("mouse", handleMouse);
-      term.off("resize", handleResize);
-    }
-    function finish(next) {
-      if (dashboardClosed) return;
-      dashboardClosed = true;
-      clearCtrlCArm();
-      clearStopTimer();
-      detachDashboardHandlers();
-      resolve(next);
     }
-    function handleKey(name) {
-      if (name === "CTRL_C") {
-        if (ctrlCArmed) {
-          child?.kill("SIGINT");
-          finish("exit");
+    if (process.stdin.isTTY) {
+      let onKeypress = function(str, key) {
+        if (!key) return;
+        if (key.ctrl && key.name === "c") {
+          if (ctrlCArmed) {
+            child?.kill("SIGINT");
+            finish("exit");
+            return;
+          }
+          ctrlCArmed = true;
+          process.stdout.write("\n" + col.yellow("  Press Ctrl+C again to exit.") + "\n");
+          ctrlCArmTimer = setTimeout(() => {
+            ctrlCArmed = false;
+          }, 1500);
           return;
         }
-        ctrlCArmed = true;
-        if (!overlayActive) redraw();
-        ctrlCArmTimer = setTimeout(() => {
-          ctrlCArmed = false;
-          if (!overlayActive) redraw();
-        }, 1500);
-        return;
-      }
-      if (overlayActive) return;
-      if (stopRequested) return;
-      const agCount = agentDisplayList().length;
-      if (name >= "1" && name <= "9") {
-        openAgentLog(parseInt(name, 10) - 1);
-        return;
-      }
-      if (name === "UP" && agCount > 0) {
-        selectedIdx = clampListIndex(selectedIdx - 1, agCount);
-        redraw();
-      } else if (name === "DOWN" && agCount > 0) {
-        selectedIdx = clampListIndex(selectedIdx + 1, agCount);
-        redraw();
-      } else if (name === "ENTER") {
-        openAgentLog(selectedIdx);
-      } else if (name === "s" || name === "S") {
-        requestStop();
-      }
+        if (stopRequested) return;
+        if (key.name === "s" || key.name === "S") {
+          requestStop();
+        }
+      };
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("keypress", onKeypress);
+      removeKeypress = () => {
+        process.stdin.off("keypress", onKeypress);
+        try {
+          if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        } catch {
+        }
+      };
     }
-    function handleMouse(name, data) {
-      if (overlayActive || stopRequested) return;
-      const idx = agentRowMap.get(data.y);
-      if (name === "MOUSE_LEFT_BUTTON_PRESSED") {
-        pressedAgentIdx = idx ?? null;
-        if (idx !== void 0 && idx !== selectedIdx) {
-          selectedIdx = idx;
-          redraw();
+    let stdoutBuffer = "";
+    const stderrChunks = [];
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk;
+      const lines = stdoutBuffer.split(/\r?\n/);
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        try {
+          const event = parseServeEventLine(line);
+          if (event) {
+            try {
+              logStore?.append(event);
+            } catch {
+            }
+            state = applyServeEvent(state, event);
+            onServeEvent(event);
+          }
+        } catch {
         }
-        return;
       }
-      if (name === "MOUSE_LEFT_BUTTON_RELEASED") {
-        const shouldOpen = idx !== void 0 && idx === pressedAgentIdx;
-        pressedAgentIdx = null;
-        if (shouldOpen) openAgentLog(idx);
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      const text = String(chunk).trim();
+      if (!text) return;
+      stderrChunks.push(text);
+      printDaemon("stderr", col.yellow(clip(text, 120)));
+      state = applyServeEvent(state, {
+        type: "daemon_stderr",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: text
+      });
+    });
+    child.on("error", (error) => {
+      print(col.red(`  Error: ${errMsg(error)}`));
+    });
+    child.once("exit", () => {
+      if (stopRequested) {
+        finish("home");
         return;
       }
-      if (idx === void 0) return;
-      if (name !== "MOUSE_LEFT_BUTTON_RELEASED") {
-        if (idx !== selectedIdx) {
-          selectedIdx = idx;
-          redraw();
-        }
+      const stderr = stderrChunks.join("\n");
+      const message = serveProcessExitMessage({ stderr, code: child.exitCode, signal: child.signalCode });
+      if (message) {
+        print(col.yellow(`
+  ${message}`));
+      } else {
+        print(col.gray("\n  Agents stopped."));
       }
-    }
-    function handleResize() {
-      if (!overlayActive) redraw();
-    }
-    term.on("key", handleKey);
-    term.on("mouse", handleMouse);
-    term.on("resize", handleResize);
-    if (child) {
-      child.once("exit", () => {
-        clearStopTimer();
-        if (stopRequested) {
-          finish("home");
-          return;
-        }
-        setTimeout(() => {
-          if (dashboardClosed || overlayActive) return;
-          exitPromptActive = true;
-          detachDashboardHandlers();
-          redraw();
-          term("\n");
-          term.gray("  Your agents have stopped. Press any key to go back\u2026");
-          term.once("key", () => finish("home"));
-        }, 600);
+      try {
+        logStore?.compact();
+      } catch {
+      }
+      removeKeypress();
+      process.stdout.write("\n  Press Enter to return to menu\u2026 ");
+      const rl = makeRl();
+      rl.once("line", () => {
+        rl.close();
+        finish("home");
       });
-    }
+      rl.once("close", () => finish("home"));
+    });
   });
 }
-async function showAgentLog({ agent, getState, env, platform }) {
-  const liveState = typeof getState === "function" ? getState : () => getState;
-  let scrollOffset = 0;
-  let autoScroll = true;
-  const visibleCount = Math.max(8, (term.height || 24) - 14);
-  function currentLogs() {
-    return agentLogEntries(liveState().agentLogs, agent.path);
-  }
-  function draw() {
-    const state = liveState();
-    const logs = currentLogs();
-    const agentObj = state.agents.find((a) => (a.relativePath || ".") === agent.path);
-    const runtime = agentObj ? agentRuntimeStatus(agentObj, state.agentRunState) : { status: "unknown", label: "offline" };
-    const status = friendlyStatus(runtime.status);
-    if (autoScroll) {
-      scrollOffset = Math.max(0, logs.length - visibleCount);
-    }
-    term.clear();
-    drawHeader({ env, platform, serveState: state });
-    term("\n");
-    term.bold(`  ${agent.name}
-`);
-    term.gray(`  ${agent.path}  \u2014  `);
-    switch (status.color) {
-      case "green":
-        term.green(`${status.icon} ${status.text}
-`);
+async function mainLoop({ env, platform }) {
+  let screen = "home";
+  while (true) {
+    let next;
+    switch (screen) {
+      case "home":
+        next = await showHome({ env, platform });
         break;
-      case "brightBlue":
-        term.brightBlue(`${status.icon} ${status.text}
-`);
+      case "connect":
+        next = await showConnect({ env, platform });
         break;
-      case "yellow":
-        term.yellow(`${status.icon} ${status.text}
-`);
+      case "create":
+        next = await showCreate({ env, platform });
         break;
-      case "red":
-        term.red(`${status.icon} ${status.text}
-`);
+      case "run":
+        next = await showRun({ env, platform });
+        break;
+      case "serve":
+        next = await showServe({ env, platform });
+        break;
+      case "commands":
+        next = await showCommands();
         break;
       default:
-        term.gray(`${status.icon} ${status.text}
-`);
-    }
-    term("\n");
-    if (logs.length === 0) {
-      term.gray("  No activity recorded yet. Logs will appear when this agent runs a job.\n");
-    } else {
-      const eff = scrollOffset >= logs.length - visibleCount - 2 ? Math.max(0, logs.length - visibleCount) : scrollOffset;
-      const visible = logs.slice(eff, eff + visibleCount);
-      const msgW = Math.max(40, (term.width || 80) - 16);
-      for (const entry of visible) {
-        const t = formatLogTime(entry.timestamp);
-        const text = clip(formatAgentLogEntry(entry), msgW);
-        term.gray(`  ${t} `);
-        if (entry.level === "error" || entry.eventType === "completion" && entry.success === false) {
-          term.red(`\u2716 ${text}
-`);
-        } else if (entry.eventType === "job_completed" && entry.success !== false) {
-          term.green(`\u2714 ${text}
-`);
-        } else if (entry.eventType === "job_started") {
-          term.brightBlue(`\u25B6 ${text}
-`);
-        } else {
-          term.gray(`\u2014 ${text}
-`);
-        }
-      }
-      if (logs.length > visibleCount) {
-        term.gray(`
-  Showing ${eff + 1}\u2013${eff + visible.length} of ${logs.length} entries
-`);
-      }
-    }
-    term("\n");
-    term.gray("  ");
-    term.brightBlue.bold("\u2191\u2193");
-    term.gray(" scroll    ");
-    term.brightBlue.bold("PgUp/PgDn");
-    term.gray(" page    ");
-    if (autoScroll) {
-      term.brightBlue.bold("Esc");
-      term.gray(" back  ");
-      term.cyan("\u2193 live\n");
-    } else {
-      term.brightBlue.bold("Esc");
-      term.gray(" back  ");
-      term.gray("\u2193 ");
-      term.brightBlue.bold("End");
-      term.gray(" resume live\n");
-    }
-  }
-  draw();
-  let overlayDone = false;
-  const redrawInterval = setInterval(() => {
-    if (!overlayDone) draw();
-  }, 500);
-  await new Promise((resolve) => {
-    function handler(name) {
-      const logs = currentLogs();
-      const maxOff = Math.max(0, logs.length - visibleCount);
-      if (name === "ESCAPE") {
-        term.off("key", handler);
-        overlayDone = true;
-        clearInterval(redrawInterval);
-        resolve();
-      } else if (name === "UP") {
-        autoScroll = false;
-        scrollOffset = Math.max(0, scrollOffset - 1);
-        draw();
-      } else if (name === "DOWN") {
-        scrollOffset = Math.min(maxOff, scrollOffset + 1);
-        if (scrollOffset >= maxOff) autoScroll = true;
-        draw();
-      } else if (name === "PAGE_UP") {
-        autoScroll = false;
-        scrollOffset = Math.max(0, scrollOffset - visibleCount);
-        draw();
-      } else if (name === "PAGE_DOWN") {
-        scrollOffset = Math.min(maxOff, scrollOffset + visibleCount);
-        if (scrollOffset >= maxOff) autoScroll = true;
-        draw();
-      } else if (name === "END") {
-        autoScroll = true;
-        draw();
-      }
-    }
-    term.on("key", handler);
-  });
-}
-function friendlyStatus(status) {
-  switch (status) {
-    case "running":
-      return { icon: "\u25B6", text: "Running a job right now", color: "brightBlue" };
-    case "preparing":
-      return { icon: "\u25CB", text: "Getting ready\u2026", color: "cyan" };
-    case "ready":
-    case "completed":
-      return { icon: "\u2714", text: "Ready and waiting", color: "green" };
-    case "disabled":
-      return { icon: "\u26A0", text: "Needs setup to run locally", color: "yellow" };
-    case "error":
-      return { icon: "\u2716", text: "Something went wrong", color: "red" };
-    default:
-      return { icon: "\u25CB", text: "Starting up\u2026", color: "gray" };
-  }
-}
-function friendlyActivityLine(entry) {
-  switch (entry.eventType) {
-    case "job_started":
-      return `Started a new job`;
-    case "job_completed":
-      return entry.success === false ? `Job failed \u2014 ${fmtErr(entry.error) || entry.message || "unknown error"}` : `Job completed successfully`;
-    case "error":
-      return `Error \u2014 ${entry.message || fmtErr(entry.error) || "unknown"}`;
-    case "log":
-      return entry.message || "Activity";
-    case "completion":
-      return entry.success ? "Finished successfully" : `Failed \u2014 ${fmtErr(entry.error) || "error"}`;
-    case "step_event":
-      return `Step ${entry.stepId || ""}${entry.message ? ": " + entry.message : ""}`;
-    case "progress": {
-      const p = entry.current != null && entry.total != null ? ` (${entry.current}/${entry.total})` : "";
-      return `${entry.message || "Working"}${p}`;
-    }
-    default:
-      return entry.message || entry.eventType || "Activity";
-  }
-}
-function friendlyName(raw) {
-  return String(raw || "").replace(/.*[\\/]/, "").replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim() || raw;
-}
-function readManifestName(absoluteFolderPath) {
-  if (!absoluteFolderPath) return null;
-  for (const fname of ["manifest.yaml", "manifest.yml"]) {
-    try {
-      const content = fs11.readFileSync(path8.join(absoluteFolderPath, fname), "utf8");
-      const m = content.match(/^name\s*:\s*['"]?([^'"\n#]+?)['"]?\s*$/m);
-      if (m?.[1]) return m[1].trim();
-    } catch {
+        next = "exit";
     }
+    if (!next || next === "exit") break;
+    screen = next;
   }
-  return null;
-}
-function attachServeChild(child, onUpdate, onExit, logStore = null) {
-  let buffer = "";
-  const stderrChunks = [];
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    buffer += chunk;
-    const lines = buffer.split(/\r?\n/);
-    buffer = lines.pop() || "";
-    const events = [];
-    for (const line of lines) {
-      try {
-        const event = parseServeEventLine(line);
-        if (event) {
-          try {
-            logStore?.append(event);
-          } catch {
-          }
-          events.push(event);
-        }
-      } catch {
-      }
-    }
-    if (events.length > 0) onUpdate((cur) => events.reduce((s, e) => applyServeEvent(s, e), cur));
-  });
-  child.stderr.setEncoding("utf8");
-  child.stderr.on("data", (chunk) => {
-    const text = String(chunk).trim();
-    if (text) {
-      stderrChunks.push(text);
-      onUpdate((cur) => applyServeEvent(cur, {
-        type: "daemon_stderr",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        message: text
-      }));
-    }
-  });
-  child.on("error", (error) => {
-    onUpdate((cur) => ({ ...cur, errors: [...cur.errors, { scope: "daemon", message: errMsg(error) }].slice(-20) }));
-  });
-  child.on("exit", (code, signal) => {
-    const stderr = stderrChunks.join("\n");
-    const stderrTail = serveProcessExitStderrTail(stderr);
-    const message = serveProcessExitMessage({ stderr, code, signal });
-    if (message) {
-      onUpdate((cur) => {
-        const event = { type: "process_exit", timestamp: (/* @__PURE__ */ new Date()).toISOString(), code, signal, message, stderrTail, relativePath: cur.currentJob?.relativePath || "", runId: cur.currentJob?.runId || "" };
-        try {
-          logStore?.append(event);
-        } catch {
-        }
-        try {
-          logStore?.compact();
-        } catch {
-        }
-        return applyServeEvent(cur, event);
-      });
-    }
-    try {
-      logStore?.compact();
-    } catch {
-    }
-    onExit({ code, signal, message });
-  });
 }
-async function withOutputMode(label, fn) {
-  term.fullscreen(false);
-  setCursorVisible(true);
-  term.grabInput(false);
-  process.stdout.write(`
-  ${label}
-  ${"\u2500".repeat(50)}
-
-`);
-  try {
-    await fn();
-  } catch (error) {
-    process.stdout.write(`
-  Something went wrong: ${errMsg(error)}
+async function runTui({
+  env = process.env,
+  platform = process.platform,
+  output = process.stdout
+} = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    output.write(`${helpText()}
 `);
-  }
-  await pressEnterToContinue({ grabActive: false });
-  term.fullscreen(true);
-  setCursorVisible(false);
-  term.grabInput({ mouse: "motion" });
-}
-function waitForKey(keys = null) {
-  return new Promise((resolve) => {
-    function handler(name) {
-      if (!keys || keys.includes(name)) {
-        term.off("key", handler);
-        resolve(name);
-      }
-    }
-    term.on("key", handler);
-  });
-}
-function setCursorVisible(visible) {
-  if (typeof term?.hideCursor === "function") {
-    term.hideCursor(!visible);
     return;
   }
-  if (visible && typeof term?.showCursor === "function") {
-    term.showCursor();
-    return;
-  }
-  if (!visible && typeof term?.hideCursor === "function") {
-    term.hideCursor();
-  }
-}
-async function pressEnterToContinue({ grabActive = true } = {}) {
-  if (grabActive) {
-    term("\n  Press any key to continue\u2026");
-    await waitForKey();
-    return;
-  }
-  process.stdout.write("\n  Press Enter to continue\u2026 ");
-  return new Promise((resolve) => {
-    const rl = readlinePromises.createInterface({ input: process.stdin });
-    rl.once("line", () => {
-      rl.close();
-      resolve();
-    });
-    rl.once("close", resolve);
-  });
-}
-function formatAgentLogEntry(entry) {
-  if (!entry) return "";
-  switch (entry.eventType) {
-    case "job_started":
-      return entry.message || `Started ${entry.jobType || "job"}`;
-    case "job_completed":
-      return entry.success === false ? `Failed: ${fmtErr(entry.error) || entry.message || "error"}` : entry.message || "Completed";
-    case "error":
-      return `Error: ${entry.message || fmtErr(entry.error) || "unknown"}`;
-    case "log":
-      return entry.message || "";
-    case "progress": {
-      const p = entry.current != null && entry.total != null ? `${entry.current}/${entry.total} ` : "";
-      return `${p}${entry.message || "progress"}`;
-    }
-    case "completion":
-      return entry.success ? "Completed" : `Failed: ${fmtErr(entry.error) || "error"}`;
-    case "step_event":
-      return `Step ${entry.stepId || ""}${entry.message ? ": " + entry.message : ""}`;
-    default:
-      return entry.message || entry.eventType || "event";
-  }
-}
-function fmtErr(error) {
-  if (!error) return "";
-  return typeof error === "object" ? error.message || "error" : String(error);
+  await refreshInteractiveManagedRuntime({ env, platform, output });
+  await mainLoop({ env, platform });
 }
-function formatLogTime(ts) {
-  if (!ts) return "     ";
+async function refreshInteractiveManagedRuntime({
+  env = process.env,
+  platform = process.platform,
+  output = process.stderr,
+  refreshPackageAccess = refreshPackageAccessFromCloudAuth,
+  autoUpdate = maybeAutoUpdateManagedEnv
+} = {}) {
+  if (env.VENDIAN_SKIP_AUTO_UPDATE === "1") return false;
   try {
-    const d = new Date(ts);
-    return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
-  } catch {
-    return "     ";
+    await refreshPackageAccess({ env, platform });
+  } catch (error) {
+    output.write(`[vendian] Package access refresh failed; continuing. ${errMsg(error)}
+`);
   }
-}
-function pad2(n) {
-  return String(n).padStart(2, "0");
+  return autoUpdate({ env, platform, force: true });
 }
 function endpointRows({ env = process.env, platform = process.platform } = {}) {
   return ENDPOINTS.map((ep) => {
@@ -3803,15 +3128,12 @@ async function connectEndpointInteractive({
   const status = cloudAuthStatus({ backend, apiUrl, env, platform });
   const destination = label || envLabel(status.apiUrl);
   if (status.authenticated) {
-    term.gray(`  Connecting to ${destination}\u2026
-`);
+    print(col.gray(`  Connecting to ${destination}\u2026`));
     try {
       await switchOrLoginEndpoint({ backend, apiUrl, env, platform, setupFn, activateFn });
-      term.green(`  ${fig.check} ${successLabel || `Signed in to ${destination} successfully`}
-`);
+      print(col.green(`  ${fig.check} ${successLabel || `Signed in to ${destination} successfully`}`));
     } catch (error) {
-      term.red(`  ${endpointErrorStatus(error)}
-`);
+      print(col.red(`  ${endpointErrorStatus(error)}`));
     }
     return { promptedInTui: true };
   }
@@ -3841,26 +3163,15 @@ function buildLocalRunArgs({
     inputJson || "{}"
   ];
 }
-function runtimeSummary({ env = process.env, platform = process.platform, now = Date.now() } = {}) {
-  const config = loadConfig(env, platform);
-  const venvPath = managedVenvPath(env, platform);
-  const installed = fs11.existsSync(venvVendian(venvPath, platform));
-  const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
-  const stale = !Number.isFinite(lastUpdate) || now - lastUpdate > 24 * 60 * 60 * 1e3;
-  return {
-    installed,
-    detail: installed ? venvPath : "Run vendian login to prepare it",
-    updateHint: installed && stale ? "Run vendian update to refresh packages" : ""
-  };
-}
-function packageAccessSummary({ env = process.env, platform = process.platform } = {}) {
-  const registry = registryConfig(loadConfig(env, platform), env, platform);
-  return { configured: Boolean(registry.token), source: registry.tokenSource || "local config" };
+function stopSignalForAttempt(attempt = 0) {
+  if (!Number.isFinite(attempt) || attempt <= 0) return "SIGINT";
+  if (attempt === 1) return "SIGTERM";
+  return "SIGKILL";
 }
 function helpText() {
   return [
     "",
-    `  ${fig.arrowUp} VENDIAN CLI v${CLI_VERSION}`,
+    `  \u2191 VENDIAN CLI v${CLI_VERSION}`,
     "",
     "  Usage:",
     "    vendian                       Open the interactive shell",
@@ -3876,7 +3187,6 @@ function helpText() {
     "    vendian init --output-dir ./agents",
     '    vendian create "My Agent" --output-dir ./agents',
     "    vendian validate ./agents/my-agent --runtime",
-    "    vendian test ./agents/my-agent --dry-run --mock-credentials",
     "    vendian models",
     "    vendian cloud local serve --agents-dir ./agents",
     "    vendian doctor",
@@ -3886,6 +3196,21 @@ function helpText() {
     ""
   ].join("\n");
 }
+function friendlyName(raw) {
+  return String(raw || "").replace(/.*[\\/]/, "").replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim() || String(raw || "");
+}
+function readManifestName(absoluteFolderPath) {
+  if (!absoluteFolderPath) return null;
+  for (const fname of ["manifest.yaml", "manifest.yml"]) {
+    try {
+      const content = fs11.readFileSync(path8.join(absoluteFolderPath, fname), "utf8");
+      const m = content.match(/^name\s*:\s*['"]?([^'"\n#]+?)['"]?\s*$/m);
+      if (m?.[1]) return m[1].trim();
+    } catch {
+    }
+  }
+  return null;
+}
 function clip(value, length) {
   const text = String(value || "");
   return text.length <= length ? text : `${text.slice(0, Math.max(0, length - 1))}\u2026`;
@@ -3893,6 +3218,26 @@ function clip(value, length) {
 function errMsg(error) {
   return error && typeof error.message === "string" ? error.message : String(error);
 }
+function fmtErr(error) {
+  if (!error) return "";
+  return typeof error === "object" ? error.message || "error" : String(error);
+}
+function shortId2(value) {
+  const text = String(value || "");
+  return text ? text.slice(0, 8) : "";
+}
+function formatLogTime(ts) {
+  if (!ts) return "     ";
+  try {
+    const d = new Date(ts);
+    return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+  } catch {
+    return "     ";
+  }
+}
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
 
 // src/main.js
 function printHelp() {