@vendian/cli 0.0.9 → 0.0.11

package/cli-wrapper.mjs

@@ -1381,7 +1381,7 @@ var require_react_development = __commonJS({
           var dispatcher = resolveDispatcher();
           return dispatcher.useReducer(reducer, initialArg, init);
         }
-        function useRef2(initialValue) {
+        function useRef3(initialValue) {
           var dispatcher = resolveDispatcher();
           return dispatcher.useRef(initialValue);
         }
@@ -2175,7 +2175,7 @@ var require_react_development = __commonJS({
         exports.useLayoutEffect = useLayoutEffect2;
         exports.useMemo = useMemo3;
         exports.useReducer = useReducer;
-        exports.useRef = useRef2;
+        exports.useRef = useRef3;
         exports.useState = useState6;
         exports.useSyncExternalStore = useSyncExternalStore;
         exports.useTransition = useTransition;
@@ -24765,10 +24765,10 @@ var require_react_reconciler_development = __commonJS({
         var setErrorHandler = null;
         var setSuspenseHandler = null;
         {
-          var copyWithDeleteImpl = function(obj, path7, index2) {
-            var key = path7[index2];
+          var copyWithDeleteImpl = function(obj, path8, index2) {
+            var key = path8[index2];
             var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-            if (index2 + 1 === path7.length) {
+            if (index2 + 1 === path8.length) {
               if (isArray(updated)) {
                 updated.splice(key, 1);
               } else {
@@ -24776,11 +24776,11 @@ var require_react_reconciler_development = __commonJS({
               }
               return updated;
             }
-            updated[key] = copyWithDeleteImpl(obj[key], path7, index2 + 1);
+            updated[key] = copyWithDeleteImpl(obj[key], path8, index2 + 1);
             return updated;
           };
-          var copyWithDelete = function(obj, path7) {
-            return copyWithDeleteImpl(obj, path7, 0);
+          var copyWithDelete = function(obj, path8) {
+            return copyWithDeleteImpl(obj, path8, 0);
           };
           var copyWithRenameImpl = function(obj, oldPath, newPath, index2) {
             var oldKey = oldPath[index2];
@@ -24818,17 +24818,17 @@ var require_react_reconciler_development = __commonJS({
             }
             return copyWithRenameImpl(obj, oldPath, newPath, 0);
           };
-          var copyWithSetImpl = function(obj, path7, index2, value) {
-            if (index2 >= path7.length) {
+          var copyWithSetImpl = function(obj, path8, index2, value) {
+            if (index2 >= path8.length) {
               return value;
             }
-            var key = path7[index2];
+            var key = path8[index2];
             var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-            updated[key] = copyWithSetImpl(obj[key], path7, index2 + 1, value);
+            updated[key] = copyWithSetImpl(obj[key], path8, index2 + 1, value);
             return updated;
           };
-          var copyWithSet = function(obj, path7, value) {
-            return copyWithSetImpl(obj, path7, 0, value);
+          var copyWithSet = function(obj, path8, value) {
+            return copyWithSetImpl(obj, path8, 0, value);
           };
           var findHook = function(fiber, id) {
             var currentHook2 = fiber.memoizedState;
@@ -24838,10 +24838,10 @@ var require_react_reconciler_development = __commonJS({
             }
             return currentHook2;
           };
-          overrideHookState = function(fiber, id, path7, value) {
+          overrideHookState = function(fiber, id, path8, value) {
             var hook = findHook(fiber, id);
             if (hook !== null) {
-              var newState = copyWithSet(hook.memoizedState, path7, value);
+              var newState = copyWithSet(hook.memoizedState, path8, value);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign({}, fiber.memoizedProps);
@@ -24851,10 +24851,10 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           };
-          overrideHookStateDeletePath = function(fiber, id, path7) {
+          overrideHookStateDeletePath = function(fiber, id, path8) {
             var hook = findHook(fiber, id);
             if (hook !== null) {
-              var newState = copyWithDelete(hook.memoizedState, path7);
+              var newState = copyWithDelete(hook.memoizedState, path8);
               hook.memoizedState = newState;
               hook.baseState = newState;
               fiber.memoizedProps = assign({}, fiber.memoizedProps);
@@ -24877,8 +24877,8 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           };
-          overrideProps = function(fiber, path7, value) {
-            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path7, value);
+          overrideProps = function(fiber, path8, value) {
+            fiber.pendingProps = copyWithSet(fiber.memoizedProps, path8, value);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -24887,8 +24887,8 @@ var require_react_reconciler_development = __commonJS({
               scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
             }
           };
-          overridePropsDeletePath = function(fiber, path7) {
-            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path7);
+          overridePropsDeletePath = function(fiber, path8) {
+            fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path8);
             if (fiber.alternate) {
               fiber.alternate.pendingProps = fiber.pendingProps;
             }
@@ -32281,7 +32281,7 @@ var init_Text = __esm({
 });
 
 // node_modules/ink/build/components/ErrorOverview.js
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import { cwd } from "node:process";
 function ErrorOverview({ error }) {
   const stack = error.stack ? error.stack.split("\n").slice(1) : void 0;
@@ -32289,8 +32289,8 @@ function ErrorOverview({ error }) {
   const filePath = cleanupPath(origin?.file);
   let excerpt;
   let lineWidth = 0;
-  if (filePath && origin?.line && fs10.existsSync(filePath)) {
-    const sourceCode = fs10.readFileSync(filePath, "utf8");
+  if (filePath && origin?.line && fs11.existsSync(filePath)) {
+    const sourceCode = fs11.readFileSync(filePath, "utf8");
     excerpt = dist_default3(sourceCode, origin.line);
     if (excerpt) {
       for (const { line } of excerpt) {
@@ -32385,8 +32385,8 @@ var init_ErrorOverview = __esm({
     init_dist3();
     init_Box();
     init_Text();
-    cleanupPath = (path7) => {
-      return path7?.replace(`file://${cwd()}/`, "");
+    cleanupPath = (path8) => {
+      return path8?.replace(`file://${cwd()}/`, "");
     };
     stackUtils = new import_stack_utils.default({
       cwd: cwd(),
@@ -36691,16 +36691,27 @@ function packageIndexEnv(config = {}, env3 = process.env, platform2 = process.pl
 function joinIndexUrls(urls) {
   return urls.flatMap((value) => String(value || "").split(/\s+/)).map((value) => value.trim()).filter(Boolean).filter((value, index, all) => all.indexOf(value) === index).join(" ");
 }
-function maybeAutoUpdateManagedEnv({ env: env3 = process.env, platform: platform2 = process.platform, venvPath = managedVenvPath(env3, platform2) } = {}) {
+function maybeAutoUpdateManagedEnv({
+  env: env3 = process.env,
+  platform: platform2 = process.platform,
+  venvPath = managedVenvPath(env3, platform2),
+  force = false,
+  log = true,
+  load = loadConfig,
+  save = saveConfig,
+  installPackages = installVendianPackages,
+  refreshDocs = refreshAgentDocsWorkspaces,
+  now = Date.now()
+} = {}) {
   if (env3.VENDIAN_SKIP_AUTO_UPDATE === "1") {
     return false;
   }
-  const config = loadConfig(env3, platform2);
+  const config = load(env3, platform2);
   const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
-  if (Number.isFinite(lastUpdate) && Date.now() - lastUpdate < AUTO_UPDATE_INTERVAL_MS) {
+  if (!force && Number.isFinite(lastUpdate) && now - lastUpdate < AUTO_UPDATE_INTERVAL_MS) {
     return false;
   }
-  const registry = registryConfig(config, env3);
+  const registry = registryConfig(config, env3, platform2);
   if (!registry.token) {
     return false;
   }
@@ -36709,32 +36720,33 @@ function maybeAutoUpdateManagedEnv({ env: env3 = process.env, platform: platform
     return false;
   }
   try {
-    console.error("[vendian] Checking managed CLI/runtime updates...");
-    installVendianPackages({ pythonPath, venvPath, config, env: env3 });
-    const next = { ...config, lastManagedUpdateAt: (/* @__PURE__ */ new Date()).toISOString() };
-    refreshAgentDocsWorkspaces({ config: next, venvPath, env: env3, platform: platform2 });
+    if (log) {
+      console.error("[vendian] Checking managed CLI/runtime updates...");
+    }
+    installPackages({ pythonPath, venvPath, config, env: env3, platform: platform2 });
+    const next = { ...config, lastManagedUpdateAt: new Date(now).toISOString() };
+    save(next, env3, platform2);
+    refreshDocs({ config: next, venvPath, env: env3, platform: platform2 });
     return true;
   } catch (error) {
     const message = error && typeof error.message === "string" ? error.message : String(error);
-    console.error(`[vendian] Update check failed; continuing with installed CLI. ${message}`);
+    if (log) {
+      console.error(`[vendian] Update check failed; continuing with installed CLI. ${message}`);
+    }
     return false;
   }
 }
 
 // src/tui.js
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import readlinePromises from "node:readline/promises";
 
-// src/npm-update.js
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
 // src/version.js
-var CLI_VERSION = true ? "0.0.9" : process.env.npm_package_version || "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.11" : process.env.npm_package_version || "0.0.0-dev";
 
 // src/npm-update.js
-var execFileAsync = promisify(execFile);
 var NPM_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
+var CLI_PACKAGE_NAME = "@vendian/cli";
 function npmPackageUpdateSummary({
   config = {},
   currentVersion = CLI_VERSION,
@@ -36757,21 +36769,14 @@ function npmPackageUpdateSummary({
 async function checkNpmPackageUpdate({
   env: env3 = process.env,
   platform: platform2 = process.platform,
-  packageName = "@vendian/cli",
+  packageName = CLI_PACKAGE_NAME,
   registry = "https://registry.npmjs.org/",
   currentVersion = CLI_VERSION,
-  timeoutMs = 4e3
+  timeoutMs = 4e3,
+  fetchImpl = globalThis.fetch
 } = {}) {
-  const npm = platform2 === "win32" ? "npm.cmd" : "npm";
-  const args = ["view", packageName, "dist-tags.latest", "--json", `--registry=${registry}`];
   try {
-    const { stdout } = await execFileAsync(npm, args, {
-      env: env3,
-      encoding: "utf8",
-      timeout: timeoutMs,
-      windowsHide: true
-    });
-    const latestVersion = parseNpmLatest(stdout);
+    const latestVersion = await latestNpmPackageVersion({ packageName, registry, timeoutMs, fetchImpl });
     const config = {
       ...loadConfig(env3, platform2),
       latestNpmCliVersion: latestVersion,
@@ -36786,6 +36791,33 @@ async function checkNpmPackageUpdate({
     };
   }
 }
+async function latestNpmPackageVersion({
+  packageName = CLI_PACKAGE_NAME,
+  registry = "https://registry.npmjs.org/",
+  timeoutMs = 4e3,
+  fetchImpl = globalThis.fetch
+} = {}) {
+  if (typeof fetchImpl !== "function") {
+    throw new Error("fetch is unavailable");
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(registryPackageUrl(registry, packageName), {
+      headers: {
+        accept: "application/vnd.npm.install-v1+json, application/json"
+      },
+      signal: controller.signal
+    });
+    if (!response?.ok) {
+      throw new Error(`npm registry returned ${response?.status || "no response"}`);
+    }
+    const metadata = await response.json();
+    return parseNpmLatest(metadata?.["dist-tags"]?.latest);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 function updateLabel({ runtime, npmUpdate }) {
   if (npmUpdate?.updateAvailable) {
     return `${npmUpdate.label} (current ${npmUpdate.currentVersion})`;
@@ -36813,6 +36845,19 @@ function parseNpmLatest(stdout) {
     return raw.replace(/^"|"$/g, "").trim();
   }
 }
+function registryPackageUrl(registry, packageName) {
+  const base = String(registry || "https://registry.npmjs.org/");
+  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+  return new URL(encodeRegistryPackageName(packageName), normalizedBase).toString();
+}
+function encodeRegistryPackageName(packageName) {
+  const name = String(packageName || "").trim();
+  if (!name.startsWith("@")) {
+    return encodeURIComponent(name);
+  }
+  const [scope, pkg] = name.slice(1).split("/");
+  return `@${encodeURIComponent(scope || "")}%2f${encodeURIComponent(pkg || "")}`;
+}
 function compareSemver(left, right) {
   const leftParts = semverParts(left);
   const rightParts = semverParts(right);
@@ -37047,6 +37092,10 @@ function initialServeState() {
     retry: null,
     errors: [],
     logs: [],
+    agentLogs: {},
+    // per-agent logs keyed by relativePath
+    agentRunState: {},
+    newAgents: [],
     stopped: false,
     jobsRun: 0
   };
@@ -37062,6 +37111,19 @@ function parseServeEventLine(line) {
   }
   return parsed;
 }
+function serveProcessExitMessage({ stderr = "", code = 0, signal = "" } = {}) {
+  const text = String(stderr || "");
+  if (/unrecognized arguments:\s*--event-stream/i.test(text)) {
+    return "Managed Vendian runtime is too old for the local serve dashboard. Run `vendian update`, then start Serve Agents again.";
+  }
+  if (code && code !== 0) {
+    return `Local serve exited with code ${code}. Toggle details for stderr.`;
+  }
+  if (signal && signal !== "SIGINT" && signal !== "SIGTERM") {
+    return `Local serve exited from ${signal}. Toggle details for stderr.`;
+  }
+  return "";
+}
 function applyServeEvent(state, event) {
   if (!event || typeof event.type !== "string") {
     return state;
@@ -37086,29 +37148,66 @@ function applyServeEvent(state, event) {
     return { ...next, activity: `Preparing ${agentLabel(event)}` };
   }
   if (event.type === "agent_prepare_completed") {
+    const runState = event.status === "error" ? setAgentRunState(state.agentRunState, agentLabel(event), {
+      status: "error",
+      lastEventAt: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      errorMessage: stringValue(event.error || event.errorMessage || "Agent setup failed")
+    }) : state.agentRunState;
     return {
       ...next,
       activity: `${agentLabel(event)} ${event.status === "error" ? "needs setup" : "ready"}`,
+      agentRunState: runState,
       errors: event.error ? appendError(state.errors, agentLabel(event), event.error) : state.errors
     };
   }
   if (event.type === "inventory_synced") {
+    const agents = Array.isArray(event.agents) ? event.agents : state.agents;
+    const newAgents = state.agents.length > 0 ? findNewAgents(state.agents, agents) : [];
     return {
       ...next,
-      agents: Array.isArray(event.agents) ? event.agents : state.agents,
-      activity: `Inventory synced (${Number(event.agentCount ?? event.agents?.length ?? 0)} agent(s))`
+      agents,
+      newAgents,
+      agentRunState: reconcileInventoryRunState(state.agentRunState, agents, event.timestamp),
+      activity: newAgents.length ? `${newAgents.length} new agent${newAgents.length === 1 ? "" : "s"} synced` : `Inventory synced (${Number(event.agentCount ?? agents.length ?? 0)} agent(s))`
     };
   }
   if (event.type === "job_started") {
+    const relativePath = agentLabel(event);
+    const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
     return {
       ...next,
+      agentLogs: appendAgentLog(state.agentLogs, event),
+      agentRunState: setAgentRunState(state.agentRunState, relativePath, {
+        status: "running",
+        runId: stringValue(event.runId || event.deployRequestId),
+        jobType: stringValue(event.jobType || "run"),
+        startedAt: timestamp,
+        completedAt: null,
+        lastEventAt: timestamp,
+        errorMessage: null
+      }),
       currentJob: event,
       activity: `Running ${jobLabel(event)}`
     };
   }
   if (event.type === "job_completed") {
+    const relativePath = agentLabel(event);
+    const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const success = event.success !== false;
+    const runId = stringValue(event.runId || event.deployRequestId);
+    const previous = (state.agentRunState || {})[relativePath];
+    const effectiveSuccess = success && !(previous?.status === "error" && previous?.runId === runId);
     return {
       ...next,
+      agentLogs: appendAgentLog(state.agentLogs, event),
+      agentRunState: setAgentRunState(state.agentRunState, relativePath, {
+        status: effectiveSuccess ? "completed" : "error",
+        runId,
+        jobType: stringValue(event.jobType || "run"),
+        completedAt: timestamp,
+        lastEventAt: timestamp,
+        errorMessage: effectiveSuccess ? null : previous?.errorMessage || stringValue(event.error || "Job failed")
+      }),
       jobsRun: state.jobsRun + 1,
       currentJob: null,
       activity: `${jobLabel(event)} completed`
@@ -37124,8 +37223,20 @@ function applyServeEvent(state, event) {
     return { ...next, retry: event, activity: `Retrying ${stringValue(event.activity)} in ${formatSeconds(event.delaySeconds)}` };
   }
   if (event.type === "error") {
+    const relativePath = event.relativePath || event.path ? agentLabel(event) : "";
+    const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const hasAgentScope = Boolean(relativePath);
     return {
       ...next,
+      agentLogs: hasAgentScope ? appendAgentLog(state.agentLogs, event) : state.agentLogs,
+      agentRunState: hasAgentScope ? setAgentRunState(state.agentRunState, relativePath, {
+        status: "error",
+        runId: stringValue(event.runId || event.deployRequestId),
+        jobType: stringValue(event.jobType || "run"),
+        completedAt: timestamp,
+        lastEventAt: timestamp,
+        errorMessage: stringValue(event.error || event.code || "Unknown error")
+      }) : state.agentRunState,
       activity: "Error",
       errors: appendError(state.errors, jobLabel(event), event.error || event.code || "Unknown error")
     };
@@ -37140,6 +37251,24 @@ function applyServeEvent(state, event) {
       jobsRun: Number(event.jobsRun ?? state.jobsRun)
     };
   }
+  if (event.type === "run_log") {
+    const entry = serveEventAgentLogEntry(event);
+    const nextRunState = entry && entry.entry.eventType === "completion" ? setAgentRunState(state.agentRunState, entry.relativePath, {
+      status: entry.entry.success === false ? "error" : "completed",
+      runId: entry.entry.runId,
+      completedAt: entry.entry.timestamp,
+      lastEventAt: entry.entry.timestamp,
+      errorMessage: entry.entry.success === false ? formatErrorMessage(entry.entry.error) : null
+    }) : entry ? setAgentRunState(state.agentRunState, entry.relativePath, {
+      runId: entry.entry.runId,
+      lastEventAt: entry.entry.timestamp
+    }) : state.agentRunState;
+    return {
+      ...next,
+      agentLogs: appendAgentLog(state.agentLogs, event),
+      agentRunState: nextRunState
+    };
+  }
   return next;
 }
 function agentSummary(agents = []) {
@@ -37161,9 +37290,254 @@ function agentSummary(agents = []) {
 function appendLog(logs, event) {
   return [...logs, event].slice(-200);
 }
+function appendAgentLog(agentLogs, event) {
+  const normalized = serveEventAgentLogEntry(event);
+  if (!normalized) {
+    return agentLogs || {};
+  }
+  const key = normalized.relativePath;
+  const existing = agentLogs[key] || [];
+  return {
+    ...agentLogs,
+    [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) {
+    if (!record || typeof record !== "object") continue;
+    const relativePath = stringValue(record.relativePath || ".");
+    const entry = record.entry && typeof record.entry === "object" ? record.entry : record;
+    const existing = next[relativePath] || [];
+    next = {
+      ...next,
+      [relativePath]: [...existing, normalizeStoredAgentLogEntry(entry)].slice(-5e3)
+    };
+  }
+  return next;
+}
+function agentRunStateFromLogs(agentLogs, { includeRunning = true } = {}) {
+  let next = {};
+  for (const [relativePath, entries] of Object.entries(agentLogs || {})) {
+    for (const entry of entries || []) {
+      const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+      const runId = stringValue(entry.runId);
+      const current = next[relativePath] || {};
+      if (entry.eventType === "job_started") {
+        next = setAgentRunState(next, relativePath, {
+          status: includeRunning ? "running" : current.status,
+          runId,
+          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
+          startedAt: timestamp,
+          lastEventAt: timestamp
+        });
+        continue;
+      }
+      if (entry.eventType === "completion" || entry.eventType === "job_completed") {
+        const failed = entry.success === false || current.status === "error" && current.runId === runId;
+        next = setAgentRunState(next, relativePath, {
+          status: failed ? "error" : "completed",
+          runId,
+          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
+          completedAt: timestamp,
+          lastEventAt: timestamp,
+          errorMessage: failed ? formatErrorMessage(entry.error) || current.errorMessage || stringValue(entry.message || "Job failed") : null
+        });
+        continue;
+      }
+      if (entry.eventType === "error" || entry.level === "error" && entry.success === false) {
+        next = setAgentRunState(next, relativePath, {
+          status: "error",
+          runId,
+          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
+          completedAt: timestamp,
+          lastEventAt: timestamp,
+          errorMessage: formatErrorMessage(entry.error) || stringValue(entry.message || "Job failed")
+        });
+        continue;
+      }
+      if (runId || timestamp) {
+        next = setAgentRunState(next, relativePath, {
+          runId: runId || current.runId,
+          lastEventAt: timestamp
+        });
+      }
+    }
+  }
+  return next;
+}
+function serveEventAgentLogEntry(event) {
+  if (!event || typeof event !== "object") {
+    return null;
+  }
+  const type = stringValue(event.type);
+  const relativePath = stringValue(event.relativePath || event.path || ".");
+  const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  if (type === "run_log") {
+    return {
+      relativePath,
+      entry: {
+        timestamp,
+        runId: stringValue(event.runId),
+        eventType: stringValue(event.eventType || "log"),
+        level: stringValue(event.level || "info"),
+        message: stringValue(event.message),
+        stepId: event.stepId ? stringValue(event.stepId) : null,
+        current: event.current ?? null,
+        total: event.total ?? null,
+        success: event.success ?? null,
+        error: event.error ?? null,
+        jobType: event.jobType ? stringValue(event.jobType) : null
+      }
+    };
+  }
+  if (type === "job_started") {
+    const jobType = stringValue(event.jobType || "run");
+    return {
+      relativePath,
+      entry: {
+        timestamp,
+        runId: stringValue(event.runId || event.deployRequestId),
+        eventType: "job_started",
+        level: "info",
+        message: `Started ${jobType}`,
+        stepId: null,
+        current: null,
+        total: null,
+        success: null,
+        error: null,
+        jobType
+      }
+    };
+  }
+  if (type === "job_completed") {
+    const success = event.success !== false;
+    const jobType = stringValue(event.jobType || "run");
+    return {
+      relativePath,
+      entry: {
+        timestamp,
+        runId: stringValue(event.runId || event.deployRequestId),
+        eventType: "job_completed",
+        level: success ? "info" : "error",
+        message: success ? "Completed successfully" : stringValue(event.error || "Failed"),
+        stepId: null,
+        current: null,
+        total: null,
+        success,
+        error: event.error ?? null,
+        jobType
+      }
+    };
+  }
+  if (type === "error" && (event.relativePath || event.path)) {
+    return {
+      relativePath,
+      entry: {
+        timestamp,
+        runId: stringValue(event.runId || event.deployRequestId),
+        eventType: "error",
+        level: "error",
+        message: stringValue(event.error || event.code || "Unknown error"),
+        stepId: null,
+        current: null,
+        total: null,
+        success: false,
+        error: event.error ?? event.code ?? null,
+        jobType: event.jobType ? stringValue(event.jobType) : null
+      }
+    };
+  }
+  return null;
+}
+function agentRuntimeStatus(agent, agentRunState = {}) {
+  const path8 = stringValue(agent?.relativePath || ".");
+  const run2 = (agentRunState || {})[path8];
+  const inventoryStatus = stringValue(agent?.status);
+  if (run2?.status === "running") {
+    return { status: "running", label: "running", run: run2 };
+  }
+  if (run2?.status === "error" || inventoryStatus === "error") {
+    return { status: "error", label: "error", run: run2 };
+  }
+  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);
 }
+function setAgentRunState(agentRunState, relativePath, patch) {
+  const key = stringValue(relativePath || ".");
+  return {
+    ...agentRunState || {},
+    [key]: {
+      ...(agentRunState || {})[key] || {},
+      ...patch
+    }
+  };
+}
+function reconcileInventoryRunState(agentRunState, agents, timestamp) {
+  let next = agentRunState || {};
+  for (const agent of agents || []) {
+    const path8 = stringValue(agent?.relativePath || ".");
+    const current = next[path8];
+    if (agent?.status === "error") {
+      next = setAgentRunState(next, path8, {
+        status: "error",
+        lastEventAt: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        errorMessage: stringValue(agent.errorMessage || agent.error || "Agent setup failed")
+      });
+    } else if (agent?.status === "online" && current?.status === "error" && !current?.runId) {
+      next = setAgentRunState(next, path8, {
+        status: "ready",
+        lastEventAt: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        errorMessage: null
+      });
+    }
+  }
+  return next;
+}
+function normalizeStoredAgentLogEntry(entry) {
+  return {
+    timestamp: entry.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    runId: stringValue(entry.runId),
+    eventType: stringValue(entry.eventType || "log"),
+    level: stringValue(entry.level || "info"),
+    message: stringValue(entry.message),
+    stepId: entry.stepId ? stringValue(entry.stepId) : null,
+    current: entry.current ?? null,
+    total: entry.total ?? null,
+    success: entry.success ?? null,
+    error: entry.error ?? null,
+    jobType: entry.jobType ? stringValue(entry.jobType) : null
+  };
+}
+function formatErrorMessage(error) {
+  if (!error) return null;
+  if (typeof error === "object") return stringValue(error.message || "error");
+  return stringValue(error);
+}
+function findNewAgents(previous, next) {
+  const seen = new Set(previous.map(agentKey).filter(Boolean));
+  return next.filter((agent) => {
+    const key = agentKey(agent);
+    return key && !seen.has(key);
+  }).slice(0, 8);
+}
+function agentKey(agent) {
+  if (!agent || typeof agent !== "object") {
+    return "";
+  }
+  return stringValue(agent.localAgentId || agent.relativePath || agent.path || agent.manifestName || agent.id);
+}
 function agentLabel(event) {
   return stringValue(event.relativePath || event.path || ".");
 }
@@ -37182,27 +37556,260 @@ function formatSeconds(value) {
 import { spawn as spawn2 } from "node:child_process";
 async function spawnLocalServeEventStream({
   agentsDir = "./agents",
+  collectionId = "",
   env: env3 = process.env,
   platform: platform2 = process.platform
 } = {}) {
-  const invocation = await preparePythonVendianInvocation([
+  const invocation = await preparePythonVendianInvocation(buildLocalServeEventStreamArgs({ agentsDir, collectionId }), { env: env3, platform: platform2 });
+  return spawn2(invocation.command, invocation.args, {
+    env: invocation.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false
+  });
+}
+function buildLocalServeEventStreamArgs({ agentsDir = "./agents", collectionId = "" } = {}) {
+  const args = [
     "cloud",
     "local",
     "serve",
     "--agents-dir",
     agentsDir || "./agents",
     "--event-stream"
-  ], { env: env3, platform: platform2 });
-  return spawn2(invocation.command, invocation.args, {
-    env: invocation.env,
-    stdio: ["ignore", "pipe", "pipe"],
-    shell: false
-  });
+  ];
+  if (collectionId) {
+    args.push("--collection-id", collectionId);
+  }
+  return args;
 }
 
+// src/serve-log-store.js
+import crypto2 from "node:crypto";
+import fs10 from "node:fs";
+import path7 from "node:path";
+var MAX_EVENTS = 5e3;
+var MAX_RUNS = 50;
+function createServeLogStore({
+  agentsDir = "./agents",
+  collectionId = "",
+  env: env3 = process.env,
+  platform: platform2 = process.platform
+} = {}) {
+  const file = serveLogFilePath({ agentsDir, collectionId, env: env3, platform: platform2 });
+  let appendCount = 0;
+  return {
+    file,
+    load() {
+      return readServeLogRecords(file);
+    },
+    append(event) {
+      const normalized = serveEventAgentLogEntry(event);
+      if (!normalized) {
+        return false;
+      }
+      fs10.mkdirSync(path7.dirname(file), { recursive: true });
+      const record = {
+        version: 1,
+        collectionId: collectionId || "",
+        agentsDir: String(agentsDir || "./agents"),
+        relativePath: normalized.relativePath,
+        entry: normalized.entry
+      };
+      fs10.appendFileSync(file, `${JSON.stringify(record)}
+`, "utf8");
+      appendCount += 1;
+      if (appendCount % 50 === 0) {
+        compactServeLogFile(file);
+      }
+      return true;
+    },
+    compact() {
+      compactServeLogFile(file);
+    }
+  };
+}
+function serveLogFilePath({
+  agentsDir = "./agents",
+  collectionId = "",
+  env: env3 = process.env,
+  platform: platform2 = process.platform
+} = {}) {
+  const root = vendianHome(env3, platform2);
+  const resolvedAgentsDir = path7.resolve(String(agentsDir || "./agents"));
+  const hash = crypto2.createHash("sha256").update(`${collectionId || "default"}\0${resolvedAgentsDir}`).digest("hex").slice(0, 16);
+  return path7.join(root, "serve-logs", `${safePathPart(collectionId || "default")}-${hash}.jsonl`);
+}
+function readServeLogRecords(file) {
+  if (!file || !fs10.existsSync(file)) {
+    return [];
+  }
+  const records = [];
+  const lines = fs10.readFileSync(file, "utf8").split(/\r?\n/);
+  for (const line of lines) {
+    const value = line.trim();
+    if (!value) continue;
+    try {
+      const record = JSON.parse(value);
+      if (record && typeof record === "object" && record.entry && record.relativePath) {
+        records.push({ relativePath: String(record.relativePath), entry: record.entry });
+      }
+    } catch {
+    }
+  }
+  return trimServeLogRecords(records);
+}
+function compactServeLogFile(file) {
+  if (!file || !fs10.existsSync(file)) {
+    return;
+  }
+  const records = readServeLogRecords(file);
+  const tmp = `${file}.tmp`;
+  fs10.writeFileSync(
+    tmp,
+    records.map((record) => JSON.stringify({ version: 1, ...record })).join("\n") + (records.length ? "\n" : ""),
+    "utf8"
+  );
+  fs10.renameSync(tmp, file);
+}
+function trimServeLogRecords(records) {
+  const runIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const runId = String(record.entry?.runId || "");
+    if (runId && !seen.has(runId)) {
+      seen.add(runId);
+      runIds.push(runId);
+    }
+  }
+  const keepRuns = new Set(runIds.slice(-MAX_RUNS));
+  return records.filter((record) => {
+    const runId = String(record.entry?.runId || "");
+    return !runId || keepRuns.has(runId);
+  }).slice(-MAX_EVENTS);
+}
+function safePathPart(value) {
+  return String(value || "default").replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "default";
+}
+
+// src/workspaces.js
+async function listCloudWorkspaces({
+  env: env3 = process.env,
+  platform: platform2 = process.platform,
+  prepareInvocation = preparePythonVendianInvocation,
+  run: run2 = runCapture
+} = {}) {
+  const invocation = await prepareInvocation(["cloud", "collections", "list", "--json"], { env: env3, platform: platform2 });
+  const result = run2(invocation.command, invocation.args, { env: invocation.env });
+  if (!result.ok) {
+    return {
+      ok: false,
+      workspaces: [],
+      error: (result.stderr || result.stdout || `workspace list exited with code ${result.status}`).trim()
+    };
+  }
+  try {
+    return { ok: true, workspaces: normalizeWorkspaceList(JSON.parse(result.stdout)), error: "" };
+  } catch (error) {
+    const message = error && typeof error.message === "string" ? error.message : String(error);
+    return { ok: false, workspaces: [], error: `Could not parse workspace list: ${message}` };
+  }
+}
+function normalizeWorkspaceList(payload) {
+  const data = payload && typeof payload === "object" && "data" in payload ? payload.data : payload;
+  const raw = Array.isArray(data) ? data : data && typeof data === "object" && Array.isArray(data.data) ? data.data : data && typeof data === "object" && Array.isArray(data.collections) ? data.collections : [];
+  return raw.filter((item) => item && typeof item === "object").map((item) => ({
+    id: stringValue2(item.id),
+    name: stringValue2(item.name || item.slug || item.id || "Unnamed workspace"),
+    slug: stringValue2(item.slug)
+  })).filter((item) => item.id);
+}
+function workspaceLabel(workspace) {
+  const name = workspace?.name || workspace?.slug || workspace?.id || "Unnamed workspace";
+  const slug = workspace?.slug && workspace.slug !== name ? ` (${workspace.slug})` : "";
+  return `${name}${slug}`;
+}
+function stringValue2(value) {
+  return value == null ? "" : String(value).trim();
+}
+
+// src/ui/theme.js
+var colors = {
+  brand: "cyan",
+  brandBold: "cyanBright",
+  success: "green",
+  error: "red",
+  warning: "yellow",
+  muted: "gray",
+  accent: "blueBright",
+  text: "white",
+  dim: "gray"
+};
+var spacing = {
+  labelWidth: 14,
+  indent: 2
+};
+
+// src/ui/figures.js
+var supportsUnicode = process.platform !== "win32" || Boolean(
+  process.env.WT_SESSION || // Windows Terminal
+  process.env.TERM_PROGRAM === "vscode" || // VS Code terminal
+  process.env.TERM === "xterm-256color" || process.env.ConEmuTask || process.env.TERMINAL_EMULATOR
+);
+var unicode = {
+  dot: "\u25CF",
+  dotEmpty: "\u25CB",
+  check: "\u2714",
+  cross: "\u2716",
+  warning: "\u26A0",
+  arrow: "\u25B6",
+  arrowRight: "\u203A",
+  arrowUp: "\u25B2",
+  dash: "\u2500",
+  ellipsis: "\u2026",
+  topLeft: "\u256D",
+  topRight: "\u256E",
+  bottomLeft: "\u2570",
+  bottomRight: "\u256F",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  teeRight: "\u251C",
+  teeLeft: "\u2524",
+  teeDown: "\u252C",
+  teeUp: "\u2534",
+  cross_join: "\u253C",
+  bar: "\u2588",
+  barEmpty: "\u2591"
+};
+var ascii = {
+  dot: "*",
+  dotEmpty: "o",
+  check: "+",
+  cross: "x",
+  warning: "!",
+  arrow: ">",
+  arrowRight: ">",
+  arrowUp: "^",
+  dash: "-",
+  ellipsis: "...",
+  topLeft: "+",
+  topRight: "+",
+  bottomLeft: "+",
+  bottomRight: "+",
+  horizontal: "-",
+  vertical: "|",
+  teeRight: "+",
+  teeLeft: "+",
+  teeDown: "+",
+  teeUp: "+",
+  cross_join: "+",
+  bar: "#",
+  barEmpty: "."
+};
+var fig = supportsUnicode ? unicode : ascii;
+
 // src/tui.js
 var h;
 var useEffect6;
+var useRef2;
 var useState5;
 var Box2;
 var Text2;
@@ -37219,15 +37826,25 @@ var ENDPOINTS = [
   { key: "prod", label: "Production" }
 ];
 var ACTIONS = [
-  { value: "connect", label: "Connect Endpoint" },
-  { value: "init", label: "Initialize Docs" },
-  { value: "create", label: "Create Agent" },
-  { value: "serve", label: "Serve Agents" },
-  { value: "doctor", label: "Doctor" },
-  { value: "update", label: "Update" },
-  { value: "commands", label: "Commands" },
-  { value: "exit", label: "Exit" }
+  { value: "connect", label: "Connect Endpoint", desc: "Switch between environments" },
+  { value: "init", label: "Initialize Docs", desc: "Set up SDK documentation workspace" },
+  { value: "create", label: "Create Agent", desc: "Scaffold a new agent from templates" },
+  { value: "serve", label: "Serve Agents", desc: "Start local development server" },
+  { value: "doctor", label: "Doctor", desc: "Check system health" },
+  { value: "update", label: "Update", desc: "Update runtime & packages" },
+  { value: "commands", label: "Commands", desc: "Show CLI command reference" },
+  { value: "exit", label: "Exit", desc: "Close interactive shell" }
 ];
+var SCREEN_TITLES = {
+  home: "Home",
+  connect: "Connect Endpoint",
+  init: "Initialize Docs",
+  create: "Create Agent",
+  serve: "Serve Agents",
+  doctor: "Doctor",
+  update: "Update",
+  commands: "Commands"
+};
 var COMMANDS = [
   "vendian login",
   "vendian init --output-dir ./agents",
@@ -37247,6 +37864,7 @@ async function runTui({ env: env3 = process.env, platform: platform2 = process.p
 `);
     return;
   }
+  await refreshInteractiveManagedRuntime({ env: env3, platform: platform2, output });
   await loadInkRuntime();
   const app = renderInk(h(VendianShell, { env: env3, platform: platform2, input, output }), {
     stdin: input,
@@ -37255,6 +37873,25 @@ async function runTui({ env: env3 = process.env, platform: platform2 = process.p
   });
   await app.waitUntilExit();
 }
+async function refreshInteractiveManagedRuntime({
+  env: env3 = process.env,
+  platform: platform2 = process.platform,
+  output = process.stderr,
+  refreshPackageAccess = refreshPackageAccessFromCloudAuth,
+  autoUpdate = maybeAutoUpdateManagedEnv
+} = {}) {
+  if (env3.VENDIAN_SKIP_AUTO_UPDATE === "1") {
+    return false;
+  }
+  try {
+    await refreshPackageAccess({ env: env3, platform: platform2 });
+  } catch (error) {
+    const message = errorMessage2(error);
+    output.write(`[vendian] Package access refresh failed; continuing with installed runtime. ${message}
+`);
+  }
+  return autoUpdate({ env: env3, platform: platform2, force: true });
+}
 async function loadInkRuntime() {
   if (h) {
     return;
@@ -37268,6 +37905,7 @@ async function loadInkRuntime() {
   ]);
   h = reactModule.default.createElement;
   useEffect6 = reactModule.useEffect;
+  useRef2 = reactModule.useRef;
   useState5 = reactModule.useState;
   Box2 = inkModule.Box;
   Text2 = inkModule.Text;
@@ -37278,11 +37916,25 @@ async function loadInkRuntime() {
   TextInput2 = textInputModule.default;
   Spinner2 = spinnerModule.default;
 }
+function endpointRows({ env: env3 = process.env, platform: platform2 = process.platform } = {}) {
+  return ENDPOINTS.map((endpoint) => {
+    const status = cloudAuthStatus({ backend: endpoint.key, env: env3, platform: platform2 });
+    const active = status.activeApiUrl === status.apiUrl;
+    return {
+      key: endpoint.key,
+      label: endpoint.label,
+      apiUrl: status.apiUrl,
+      active,
+      status: status.authenticated ? active ? "connected" : "signed in" : "not signed in",
+      detail: status.authenticated ? status.email || status.apiUrl : status.apiUrl
+    };
+  });
+}
 function runtimeSummary({ env: env3 = process.env, platform: platform2 = process.platform, now = Date.now() } = {}) {
   const config = loadConfig(env3, platform2);
   const venvPath = managedVenvPath(env3, platform2);
   const vendianPath = venvVendian(venvPath, platform2);
-  const installed = fs11.existsSync(vendianPath);
+  const installed = fs12.existsSync(vendianPath);
   const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
   const stale = !Number.isFinite(lastUpdate) || now - lastUpdate > 24 * 60 * 60 * 1e3;
   return {
@@ -37298,37 +37950,92 @@ function packageAccessSummary({ env: env3 = process.env, platform: platform2 = p
     source: registry.tokenSource || "local config"
   };
 }
+function isCtrlCInput(input = "", key = {}) {
+  return input === "" || input === "" || Boolean(key?.ctrl && (key.name === "c" || input === "c"));
+}
 function VendianShell({ env: env3, platform: platform2, input, output }) {
   const app = useApp2();
   const [screen, setScreen] = useState5("home");
   const [serveState, setServeState] = useState5(null);
-  useInput2((_, key) => {
-    if (key.ctrl && key.name === "c" && screen !== "serve") {
+  const [exitArmed, setExitArmed] = useState5(false);
+  const exitTimer = useRef2(null);
+  const lastInterruptAt = useRef2(0);
+  function armExit() {
+    if (exitArmed) {
       app.exit();
+      return;
+    }
+    setExitArmed(true);
+    if (exitTimer.current) {
+      clearTimeout(exitTimer.current);
+    }
+    exitTimer.current = setTimeout(() => setExitArmed(false), 1500);
+  }
+  function handleInterrupt() {
+    const now = Date.now();
+    if (now - lastInterruptAt.current < 75) {
+      return;
+    }
+    lastInterruptAt.current = now;
+    if (screen === "serve") {
+      return;
+    }
+    armExit();
+  }
+  useEffect6(() => () => {
+    if (exitTimer.current) {
+      clearTimeout(exitTimer.current);
+    }
+  }, []);
+  useEffect6(() => {
+    const onData = (chunk) => {
+      if (isCtrlCInput(String(chunk || ""))) {
+        handleInterrupt();
+      }
+    };
+    input?.on?.("data", onData);
+    process.on("SIGINT", handleInterrupt);
+    return () => {
+      input?.off?.("data", onData);
+      process.off("SIGINT", handleInterrupt);
+    };
+  }, [input, screen, exitArmed]);
+  useInput2((typedInput, key) => {
+    if (isCtrlCInput(typedInput, key)) {
+      handleInterrupt();
     }
   });
   const goHome = () => setScreen("home");
+  const breadcrumb = screen !== "home" ? ["Home", SCREEN_TITLES[screen] || screen] : ["Home"];
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Header, { env: env3, platform: platform2, serveState }),
+    h(Header, { env: env3, platform: platform2, serveState, screen }),
+    h(
+      Text2,
+      { color: colors.muted },
+      breadcrumb.map(
+        (part, i) => i < breadcrumb.length - 1 ? `${part} ${fig.arrowRight} ` : part
+      ).join("")
+    ),
+    h(Text2, null, ""),
     screen === "home" && h(HomeScreen, { onSelect: (value) => value === "exit" ? app.exit() : setScreen(value) }),
     screen === "connect" && h(ConnectScreen, { env: env3, platform: platform2, onBack: goHome }),
     screen === "init" && h(InitScreen, { env: env3, platform: platform2, onBack: goHome }),
     screen === "create" && h(CreateScreen, { env: env3, platform: platform2, onBack: goHome }),
-    screen === "serve" && h(ServeScreen, { env: env3, platform: platform2, input, output, onBack: goHome, onState: setServeState }),
+    screen === "serve" && h(ServeScreen, { env: env3, platform: platform2, input, output, onBack: goHome, onState: setServeState, onExitApp: app.exit }),
     screen === "doctor" && h(DoctorScreen, { env: env3, platform: platform2, onBack: goHome }),
     screen === "update" && h(UpdateScreen, { env: env3, platform: platform2, onBack: goHome }),
-    screen === "commands" && h(CommandsScreen, { onBack: goHome })
+    screen === "commands" && h(CommandsScreen, { onBack: goHome }),
+    exitArmed && screen !== "serve" && h(Text2, { color: colors.warning, bold: true }, "  Press Ctrl+C again to exit.")
   );
 }
-function Header({ env: env3, platform: platform2, serveState }) {
+function Header({ env: env3, platform: platform2, serveState, screen }) {
   const active = activeCloudAuthStatus({ env: env3, platform: platform2 });
   const runtime = runtimeSummary({ env: env3, platform: platform2 });
   const [npmUpdate, setNpmUpdate] = useState5(() => npmPackageUpdateSummary({ config: loadConfig(env3, platform2) }));
   const [npmCheckStarted, setNpmCheckStarted] = useState5(false);
   const pkg = packageAccessSummary({ env: env3, platform: platform2 });
-  const daemon = serveState?.daemonId ? `Daemon ${serveState.daemonId} | ${serveState.activity}` : "Daemon idle";
   useEffect6(() => {
     let cancelled = false;
     if (!npmUpdate.stale || npmCheckStarted) {
@@ -37344,29 +38051,111 @@ function Header({ env: env3, platform: platform2, serveState }) {
       cancelled = true;
     };
   }, [env3, platform2, npmCheckStarted, npmUpdate.stale]);
+  const connStatus = active.authenticated ? "ok" : "error";
+  const connValue = active.authenticated ? `${active.email || "Authenticated"} ${fig.dash} ${active.apiUrl}` : "Not connected \u2014 run vendian login";
+  const rtStatus = runtime.installed ? "ok" : "error";
+  const rtValue = runtime.installed ? "Ready" : "Missing \u2014 run vendian login";
+  const pkgStatus = pkg.configured ? "ok" : "warning";
+  const pkgValue = pkg.configured ? `Configured (${pkg.source})` : "Missing";
+  const updValue = updateLabel({ runtime, npmUpdate });
+  const updStatus = updValue.includes("available") ? "warning" : "ok";
+  const w = Math.min(process.stdout.columns || 80, 90);
+  const inner = w - 2;
+  const titleLeft = `${fig.vertical}  ${fig.arrowUp} VENDIAN`;
+  const titleRight = `v${CLI_VERSION}  ${fig.vertical}`;
+  const titlePad = Math.max(0, inner - titleLeft.length - titleRight.length + 2);
   return h(
     Box2,
     { flexDirection: "column", marginBottom: 1 },
-    h(Text2, { bold: true, color: "cyan" }, `VENDIAN CLI ${CLI_VERSION}`),
-    h(Text2, null, `Endpoint: ${active.authenticated ? `${active.apiUrl}${active.email ? ` (${active.email})` : ""}` : "not connected"}`),
-    h(Text2, null, `Runtime: ${runtime.installed ? "ready" : "missing"} | Package access: ${pkg.configured ? `configured (${pkg.source})` : "missing"} | Update: ${updateLabel({ runtime, npmUpdate })}`),
-    h(Text2, null, daemon)
+    h(Text2, { color: colors.muted }, `${fig.topLeft}${fig.horizontal.repeat(inner)}${fig.topRight}`),
+    h(
+      Text2,
+      null,
+      h(Text2, { color: colors.muted }, fig.vertical),
+      h(Text2, { bold: true, color: colors.brand }, `  ${fig.arrowUp} VENDIAN`),
+      h(Text2, null, " ".repeat(titlePad)),
+      h(Text2, { color: colors.muted }, `v${CLI_VERSION}  `),
+      h(Text2, { color: colors.muted }, fig.vertical)
+    ),
+    h(Text2, { color: colors.muted }, `${fig.teeRight}${fig.horizontal.repeat(inner)}${fig.teeLeft}`),
+    h(StatusRow, { status: connStatus, label: "Endpoint", value: connValue, width: inner }),
+    h(StatusRow, { status: rtStatus, label: "Runtime", value: rtValue, width: inner }),
+    h(StatusRow, { status: pkgStatus, label: "Packages", value: pkgValue, width: inner }),
+    h(StatusRow, { status: updStatus, label: "Updates", value: updValue, width: inner }),
+    serveState?.daemonId && h(StatusRow, {
+      status: serveState.connected ? "ok" : "warning",
+      label: "Daemon",
+      value: serveState.activity || "Running",
+      width: inner
+    }),
+    h(Text2, { color: colors.muted }, `${fig.bottomLeft}${fig.horizontal.repeat(inner)}${fig.bottomRight}`)
+  );
+}
+function StatusRow({ status, label, value, width }) {
+  const dotColor = status === "ok" ? colors.success : status === "warning" ? colors.warning : colors.error;
+  const dot = status === "ok" ? fig.dot : status === "warning" ? fig.dot : fig.dot;
+  const paddedLabel = String(label).padEnd(spacing.labelWidth);
+  const maxVal = Math.max(0, (width || 70) - spacing.labelWidth - 6);
+  const clipped = clip(value || "", maxVal);
+  return h(
+    Text2,
+    null,
+    h(Text2, { color: colors.muted }, `${fig.vertical}  `),
+    h(Text2, { color: dotColor }, `${dot} `),
+    h(Text2, { bold: true }, paddedLabel),
+    h(Text2, null, clipped),
+    h(Text2, { color: colors.muted }, `  ${fig.vertical}`)
   );
 }
 function HomeScreen({ onSelect }) {
+  const [activeIndex, setActiveIndex] = useState5(0);
+  useInput2((input, key) => {
+    if (key.upArrow) {
+      setActiveIndex((i) => (i - 1 + ACTIONS.length) % ACTIONS.length);
+    } else if (key.downArrow) {
+      setActiveIndex((i) => (i + 1) % ACTIONS.length);
+    } else if (key.return) {
+      onSelect(ACTIONS[activeIndex].value);
+    }
+  });
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Text2, { bold: true }, "Home"),
-    h(SelectInput2, { items: ACTIONS, onSelect: (item) => onSelect(item.value) })
+    ...ACTIONS.map((action, i) => {
+      const isActive = i === activeIndex;
+      const isSeparator = action.value === "doctor";
+      return h(
+        Box2,
+        { key: action.value, flexDirection: "column" },
+        isSeparator && h(Text2, { color: colors.muted }, `  ${fig.horizontal.repeat(40)}`),
+        h(
+          Text2,
+          null,
+          h(Text2, { color: isActive ? colors.accent : colors.muted }, isActive ? `  ${fig.arrow} ` : "    "),
+          h(Text2, { bold: isActive, color: isActive ? colors.text : colors.muted }, action.label.padEnd(22)),
+          h(Text2, { color: colors.dim }, action.desc)
+        )
+      );
+    }),
+    h(Text2, null, ""),
+    h(FooterBar, { items: [
+      { key: "\u2191\u2193", label: "Navigate" },
+      { key: "\u23CE", label: "Select" },
+      { key: "^c ^c", label: "Exit" }
+    ] })
   );
 }
 function ConnectScreen({ env: env3, platform: platform2, onBack }) {
   const [mode, setMode] = useState5("select");
   const [apiUrl, setApiUrl] = useState5("");
   const [status, setStatus] = useState5("");
+  const rows = endpointRows({ env: env3, platform: platform2 });
   const items = [
-    ...ENDPOINTS.map((endpoint) => ({ label: `${endpoint.label} ${BACKEND_TARGETS[endpoint.key]}`, value: endpoint.key })),
+    ...ENDPOINTS.map((endpoint) => {
+      const row = rows.find((r) => r.key === endpoint.key);
+      const statusLabel = row ? row.active ? "\u25CF Connected" : row.status : "";
+      return { label: `${endpoint.label.padEnd(12)} ${BACKEND_TARGETS[endpoint.key]}  ${statusLabel}`, value: endpoint.key };
+    }),
     { label: "Custom API URL", value: "custom" },
     { label: "Back", value: "back" }
   ];
@@ -37379,41 +38168,47 @@ function ConnectScreen({ env: env3, platform: platform2, onBack }) {
       setMode("custom");
       return;
     }
-    setStatus(`Connecting ${value}`);
+    setStatus(`Connecting to ${value}...`);
     await setup({ backend: value, forceAuth: true, env: env3, platform: platform2 });
-    setStatus("Connected");
+    setStatus(`${fig.check} Connected`);
   }
   if (mode === "custom") {
     return h(
       Box2,
       { flexDirection: "column" },
-      h(Text2, { bold: true }, "Connect Endpoint"),
+      h(Text2, { bold: true }, "  Enter custom API URL:"),
+      h(Text2, null, ""),
       h(TextInput2, {
         value: apiUrl,
         placeholder: "https://api.example.test",
         onChange: setApiUrl,
         onSubmit: async (value) => {
           if (!value) return;
-          setStatus("Connecting custom endpoint");
+          setStatus("Connecting...");
           await setup({ apiUrl: value, forceAuth: true, env: env3, platform: platform2 });
-          setStatus("Connected");
+          setStatus(`${fig.check} Connected`);
         }
       }),
-      h(Text2, null, status),
+      status && h(Text2, { color: status.includes(fig.check) ? colors.success : colors.muted }, `  ${status}`),
+      h(Text2, null, ""),
+      h(FooterBar, { items: [{ key: "\u23CE", label: "Submit" }, { key: "esc", label: "Back" }] }),
       h(BackHint, { onBack })
     );
   }
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Text2, { bold: true }, "Connect Endpoint"),
+    h(Text2, { bold: true }, "  Select environment:"),
+    h(Text2, null, ""),
     h(SelectInput2, { items, onSelect: (item) => connect(item.value) }),
-    status && h(Text2, null, status)
+    status && h(Text2, { color: status.includes(fig.check) ? colors.success : colors.muted }, `  ${status}`),
+    h(Text2, null, ""),
+    h(FooterBar, { items: [{ key: "\u2191\u2193", label: "Navigate" }, { key: "\u23CE", label: "Select" }, { key: "esc", label: "Back" }] })
   );
 }
 function InitScreen({ env: env3, platform: platform2, onBack }) {
   return h(CommandPromptScreen, {
-    title: "Initialize Docs",
+    title: "  Initialize Docs",
     label: "Workspace directory",
     initialValue: ".",
     onBack,
@@ -37453,53 +38248,180 @@ function CreateScreen({ env: env3, platform: platform2, onBack }) {
     h(BackHint, { onBack })
   );
 }
-function ServeScreen({ env: env3, platform: platform2, onBack, onState }) {
+function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, onExitApp }) {
   const [agentDirCandidates] = useState5(() => findAgentDirectoryCandidates());
   const [agentsDir, setAgentsDir] = useState5(() => defaultAgentsDir(agentDirCandidates));
   const [selectingDir, setSelectingDir] = useState5(() => agentDirCandidates.length > 0);
+  const [workspaceChoices, setWorkspaceChoices] = useState5([]);
+  const [pendingAgentsDir, setPendingAgentsDir] = useState5("");
+  const [loadingWorkspaces, setLoadingWorkspaces] = useState5(false);
   const [started, setStarted] = useState5(false);
   const [state, setState] = useState5(initialServeState());
   const [child, setChild] = useState5(null);
-  const [showLogs, setShowLogs] = useState5(false);
+  const [logMode, setLogMode] = useState5(null);
   const [confirmExit, setConfirmExit] = useState5(false);
+  const [exitArmed, setExitArmed] = useState5(false);
   const [startupError, setStartupError] = useState5("");
+  const exitTimer = useRef2(null);
+  const lastInterruptAt = useRef2(0);
   useEffect6(() => {
     onState(state);
   }, [state, onState]);
-  useInput2((input, key) => {
+  useEffect6(() => () => {
+    if (exitTimer.current) {
+      clearTimeout(exitTimer.current);
+    }
+  }, []);
+  function armExit() {
+    if (exitArmed) {
+      child?.kill("SIGINT");
+      onState(null);
+      onExitApp();
+      return;
+    }
+    setExitArmed(true);
+    setConfirmExit(false);
+    if (exitTimer.current) {
+      clearTimeout(exitTimer.current);
+    }
+    exitTimer.current = setTimeout(() => setExitArmed(false), 1500);
+  }
+  function handleInterrupt() {
+    const now = Date.now();
+    if (now - lastInterruptAt.current < 75) {
+      return;
+    }
+    lastInterruptAt.current = now;
+    armExit();
+  }
+  useEffect6(() => {
+    const onData = (chunk) => {
+      if (isCtrlCInput(String(chunk || ""))) {
+        handleInterrupt();
+      }
+    };
+    input?.on?.("data", onData);
+    process.on("SIGINT", handleInterrupt);
+    return () => {
+      input?.off?.("data", onData);
+      process.off("SIGINT", handleInterrupt);
+    };
+  }, [input, exitArmed, child]);
+  useInput2((input2, key) => {
+    if (isCtrlCInput(input2, key)) {
+      handleInterrupt();
+      return;
+    }
     if (!started) return;
+    if (logMode !== null) {
+      if (key.escape) {
+        if (logMode === "picker") {
+          setLogMode(null);
+        } else {
+          setLogMode("picker");
+        }
+      }
+      return;
+    }
     if (confirmExit) {
-      if (input.toLowerCase() === "y" || key.return) {
+      if (input2.toLowerCase() === "y" || key.return) {
         child?.kill("SIGINT");
         onState(null);
         onBack();
-      } else if (input.toLowerCase() === "n" || key.escape) {
+      } else if (input2.toLowerCase() === "n" || key.escape) {
         setConfirmExit(false);
       }
       return;
     }
-    if (input === "l") {
-      setShowLogs((value) => !value);
-    } else if (input === "q" || key.ctrl && key.name === "c") {
+    if (input2 === "l") {
+      setLogMode("picker");
+    } else if (input2 === "q") {
       setConfirmExit(true);
     }
   });
-  async function start(selectedAgentsDir = agentsDir) {
+  async function start(selectedAgentsDir = agentsDir, collectionId = "") {
     const serveRoot = selectedAgentsDir || "./agents";
     setAgentsDir(serveRoot);
     setStarted(true);
     setStartupError("");
     try {
-      const nextChild = await spawnLocalServeEventStream({ agentsDir: serveRoot, env: env3, platform: platform2 });
+      const logStore = createServeLogStore({ agentsDir: serveRoot, collectionId, env: env3, platform: platform2 });
+      const historicalLogs = logStore.load();
+      if (historicalLogs.length > 0) {
+        setState((current) => {
+          const agentLogs = mergeAgentLogRecords(current.agentLogs, historicalLogs);
+          return {
+            ...current,
+            agentLogs,
+            agentRunState: {
+              ...agentRunStateFromLogs(agentLogs, { includeRunning: false }),
+              ...current.agentRunState
+            }
+          };
+        });
+      }
+      const nextChild = await spawnLocalServeEventStream({ agentsDir: serveRoot, collectionId, env: env3, platform: platform2 });
       setChild(nextChild);
-      attachServeChild(nextChild, setState, setStartupError, () => {
-        setState((current) => current.stopped ? current : { ...current, stopped: true, activity: "Process exited" });
-      });
+      attachServeChild(nextChild, setState, setStartupError, ({ message } = {}) => {
+        setState((current) => current.stopped ? current : { ...current, stopped: true, activity: message ? "Runtime update required" : "Process exited" });
+      }, logStore);
+    } catch (error) {
+      setStartupError(errorMessage2(error));
+    }
+  }
+  async function chooseWorkspaceThenStart(selectedAgentsDir = agentsDir) {
+    const serveRoot = selectedAgentsDir || "./agents";
+    setAgentsDir(serveRoot);
+    setPendingAgentsDir(serveRoot);
+    setStartupError("");
+    setLoadingWorkspaces(true);
+    try {
+      const result = await listCloudWorkspaces({ env: env3, platform: platform2 });
+      if (!result.ok) {
+        setStartupError(result.error || "Could not list workspaces.");
+        return;
+      }
+      if (result.workspaces.length > 1) {
+        setWorkspaceChoices(result.workspaces);
+        return;
+      }
+      await start(serveRoot, result.workspaces[0]?.id || "");
     } catch (error) {
       setStartupError(errorMessage2(error));
+    } finally {
+      setLoadingWorkspaces(false);
     }
   }
   if (!started) {
+    if (workspaceChoices.length > 1) {
+      return h(
+        Box2,
+        { flexDirection: "column" },
+        h(Text2, { bold: true }, "Select workspace:"),
+        h(SelectInput2, {
+          items: [
+            ...workspaceChoices.map((workspace) => ({
+              label: workspaceLabel(workspace),
+              value: workspace.id
+            })),
+            { label: "Back", value: "__back__" }
+          ],
+          onSelect: (item) => {
+            if (item.value === "__back__") {
+              setWorkspaceChoices([]);
+              return;
+            }
+            start(pendingAgentsDir || agentsDir, item.value);
+          }
+        }),
+        h(Text2, null, ""),
+        h(FooterBar, { items: [
+          { key: "\u2191\u2193", label: "Navigate" },
+          { key: "\u23CE", label: "Select" },
+          { key: "esc", label: "Back" }
+        ] })
+      );
+    }
     const items = [
       ...agentDirCandidates.map((candidate) => ({
         label: `${candidate.path} (${candidate.agentCount} ${candidate.agentCount === 1 ? "agent" : "agents"})`,
@@ -37511,7 +38433,7 @@ function ServeScreen({ env: env3, platform: platform2, onBack, onState }) {
     return h(
       Box2,
       { flexDirection: "column" },
-      h(Text2, { bold: true }, "Serve Agents"),
+      h(Text2, { bold: true }, "Select agent directory:"),
       selectingDir && h(SelectInput2, {
         items,
         onSelect: (item) => {
@@ -37525,77 +38447,434 @@ function ServeScreen({ env: env3, platform: platform2, onBack, onState }) {
             return;
           }
           setAgentsDir(item.value);
-          start(item.value);
+          chooseWorkspaceThenStart(item.value);
         }
       }),
       !selectingDir && h(TextInput2, {
         value: agentsDir,
         placeholder: "./agents",
         onChange: setAgentsDir,
-        onSubmit: (value) => start(value)
+        onSubmit: (value) => chooseWorkspaceThenStart(value)
       }),
-      h(BackHint, { onBack })
+      loadingWorkspaces && h(
+        Box2,
+        null,
+        h(Text2, { color: colors.brand }, "  "),
+        h(Spinner2, { type: "dots" }),
+        h(Text2, { color: colors.brand }, " Loading workspaces")
+      ),
+      startupError && h(Text2, { color: colors.error }, `  ${fig.cross} ${startupError}`),
+      h(Text2, null, ""),
+      h(FooterBar, { items: [
+        { key: "\u2191\u2193", label: "Navigate" },
+        { key: "\u23CE", label: "Select" },
+        { key: "esc", label: "Back" }
+      ] })
     );
   }
   const summary = agentSummary(state.agents);
+  if (logMode !== null) {
+    return h(
+      Box2,
+      { flexDirection: "column" },
+      h(AgentLogViewer, {
+        agents: state.agents,
+        agentLogs: state.agentLogs,
+        agentRunState: state.agentRunState,
+        logMode,
+        onSelectAgent: (path8) => setLogMode(path8),
+        onBack: () => {
+          if (logMode === "picker") {
+            setLogMode(null);
+          } else {
+            setLogMode("picker");
+          }
+        }
+      })
+    );
+  }
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Text2, { bold: true }, "Serve Agents"),
-    startupError ? h(Text2, { color: "red" }, startupError) : h(Box2, null, h(Spinner2, { type: "dots" }), h(Text2, null, ` ${state.activity}`)),
-    h(Text2, null, `Agents: ${summary.total} total | ${summary.ready} ready | ${summary.needsSetup} needs setup | ${summary.errors} errors`),
-    h(AgentTable, { agents: state.agents }),
-    state.retry && h(Text2, { color: "yellow" }, `Retry: ${state.retry.activity} in ${Number(state.retry.delaySeconds || 0).toFixed(1)}s`),
-    state.errors.slice(-3).map((item, index) => h(Text2, { key: `error-${index}`, color: "red" }, `${item.scope}: ${item.message}`)),
-    showLogs && h(LogPane, { logs: state.logs }),
-    confirmExit && h(Text2, { color: "yellow" }, "Stop local serve? y/Enter confirms, n/Esc cancels."),
-    h(Text2, { dimColor: true }, "l toggles details | q exits serve")
+    startupError ? h(Text2, { color: colors.error }, `  ${fig.cross} ${startupError}`) : h(
+      Box2,
+      null,
+      h(Text2, { color: colors.brand }, "  "),
+      h(Spinner2, { type: "dots" }),
+      h(Text2, { color: colors.brand }, ` ${state.activity}`)
+    ),
+    h(Text2, null, ""),
+    h(
+      Text2,
+      null,
+      h(Text2, { color: colors.muted }, "  Agents: "),
+      h(Text2, { color: colors.success, bold: true }, `${summary.ready} ready`),
+      summary.needsSetup > 0 && h(Text2, { color: colors.warning }, ` ${fig.dot} ${summary.needsSetup} needs setup`),
+      summary.errors > 0 && h(Text2, { color: colors.error }, ` ${fig.dot} ${summary.errors} errors`),
+      h(Text2, { color: colors.muted }, ` ${fig.dot} ${summary.total} total`)
+    ),
+    h(Text2, null, ""),
+    state.newAgents?.length > 0 && h(
+      Text2,
+      { color: colors.success },
+      `  ${fig.check} New agents synced automatically: ${state.newAgents.map((agent) => agent.relativePath || agent.manifestName || agent.path || "agent").join(", ")}`
+    ),
+    h(AgentTable, { agents: state.agents, agentRunState: state.agentRunState }),
+    state.retry && h(Text2, { color: colors.warning }, `  ${fig.warning} Retry: ${state.retry.activity} in ${Number(state.retry.delaySeconds || 0).toFixed(1)}s`),
+    state.errors.length > 0 && h(
+      Box2,
+      { flexDirection: "column", marginTop: 1 },
+      ...state.errors.slice(-3).map((item, index) => h(Text2, { key: `error-${index}`, color: colors.error }, `  ${fig.cross} ${item.scope}: ${item.message}`))
+    ),
+    h(Text2, null, ""),
+    confirmExit ? h(
+      Text2,
+      { color: colors.warning, bold: true },
+      "  Stop local serve? ",
+      h(Text2, { color: colors.accent }, "y"),
+      h(Text2, { color: colors.muted }, "/"),
+      h(Text2, { color: colors.accent }, "n")
+    ) : h(FooterBar, { items: [
+      { key: "l", label: "Agent logs" },
+      { key: "q", label: "Stop" },
+      { key: "^c ^c", label: "Exit" }
+    ] }),
+    exitArmed && h(Text2, { color: colors.warning, bold: true }, "  Press Ctrl+C again to exit.")
   );
 }
-function AgentTable({ agents }) {
+function AgentTable({ agents, agentRunState = {} }) {
   if (!agents.length) {
-    return h(Text2, { dimColor: true }, "No agents discovered yet.");
+    return h(Text2, { color: colors.muted }, `  ${fig.dotEmpty} No agents discovered yet.`);
+  }
+  const termWidth = Math.min(process.stdout.columns || 80, 100);
+  const pathW = Math.min(22, Math.floor(termWidth * 0.25));
+  const nameW = Math.min(28, Math.floor(termWidth * 0.32));
+  const credW = 10;
+  const statusW = 10;
+  const headerLine = `  ${"Path".padEnd(pathW)} ${"Name".padEnd(nameW)} ${"Creds".padEnd(credW)} ${"Status".padEnd(statusW)}`;
+  const separator = `  ${fig.horizontal.repeat(pathW + nameW + credW + statusW + 3)}`;
+  const rows = agents.slice(0, 16).map((agent) => {
+    const path8 = clip(agent.relativePath || ".", pathW);
+    const name = clip(agent.manifestName || agent.manifest?.name || "-", nameW);
+    const creds = credentialLabel(agent);
+    const runtime = agentRuntimeStatus(agent, agentRunState);
+    const status = runtime.label || "-";
+    const statusColor = runtimeStatusColor(runtime.status);
+    const statusIcon = runtimeStatusIcon(runtime.status);
+    return h(
+      Text2,
+      { key: agent.localAgentId || agent.relativePath },
+      h(Text2, { color: colors.muted }, "  "),
+      h(Text2, null, path8.padEnd(pathW)),
+      h(Text2, null, " "),
+      h(Text2, null, name.padEnd(nameW)),
+      h(Text2, null, " "),
+      h(Text2, { color: colors.muted }, creds.padEnd(credW)),
+      h(Text2, null, " "),
+      h(Text2, { color: statusColor }, `${statusIcon} ${status}`)
+    );
+  });
+  const hiddenCount = agents.length - 16;
+  return h(
+    Box2,
+    { flexDirection: "column" },
+    h(Text2, { color: colors.muted, bold: true }, headerLine),
+    h(Text2, { color: colors.muted }, separator),
+    ...rows,
+    hiddenCount > 0 && h(Text2, { color: colors.muted }, `  ${fig.ellipsis} and ${hiddenCount} more`)
+  );
+}
+function runtimeStatusColor(status) {
+  if (status === "running") return colors.accent;
+  if (status === "ready" || status === "completed") return colors.success;
+  if (status === "error") return colors.error;
+  return colors.warning;
+}
+function runtimeStatusIcon(status) {
+  if (status === "running") return fig.arrow;
+  if (status === "ready" || status === "completed") return fig.dot;
+  if (status === "error") return fig.cross;
+  return fig.dotEmpty;
+}
+function FooterBar({ items }) {
+  if (!items || !items.length) return null;
+  return h(
+    Text2,
+    { color: colors.muted },
+    "  ",
+    ...items.map((item, i) => [
+      h(Text2, { key: `k-${i}`, color: colors.accent, bold: true }, item.key),
+      h(Text2, { key: `l-${i}`, color: colors.muted }, ` ${item.label}`),
+      i < items.length - 1 ? h(Text2, { key: `s-${i}` }, "  ") : null
+    ]).flat().filter(Boolean)
+  );
+}
+function AgentLogViewer({ agents, agentLogs, agentRunState, logMode, onSelectAgent, onBack }) {
+  if (logMode === "picker") {
+    return h(AgentLogPicker, { agents, agentLogs, agentRunState, onSelectAgent, onBack });
+  }
+  return h(AgentLogDetail, { relativePath: logMode, agentLogs, agentRunState, agents, onBack });
+}
+function AgentLogPicker({ agents, agentLogs, agentRunState = {}, onSelectAgent, onBack }) {
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const agentList = agents.map((agent) => {
+    const path8 = agent.relativePath || ".";
+    const logs = agentLogEntries(agentLogs, path8);
+    const lastLog = logs.length > 0 ? logs[logs.length - 1] : null;
+    const hasErrors = logs.some((l) => l.level === "error" || l.eventType === "completion" && l.success === false);
+    return {
+      path: path8,
+      name: agent.manifestName || agent.manifest?.name || path8,
+      logCount: logs.length,
+      lastLog,
+      hasErrors,
+      status: agentRuntimeStatus(agent, agentRunState)
+    };
+  });
+  const inventoryPaths = new Set(agentList.map((a) => a.path));
+  for (const path8 of Object.keys(agentLogs || {})) {
+    if (!inventoryPaths.has(path8)) {
+      const logs = agentLogEntries(agentLogs, path8);
+      agentList.push({
+        path: path8,
+        name: path8,
+        logCount: logs.length,
+        lastLog: logs.length > 0 ? logs[logs.length - 1] : null,
+        hasErrors: logs.some((l) => l.level === "error"),
+        status: { status: "unknown", label: "offline" }
+      });
+    }
   }
+  useInput2((input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((i) => (i - 1 + agentList.length) % agentList.length);
+    } else if (key.downArrow) {
+      setSelectedIndex((i) => (i + 1) % agentList.length);
+    } else if (key.return) {
+      if (agentList.length > 0) {
+        onSelectAgent(agentList[selectedIndex].path);
+      }
+    } else if (key.escape) {
+      onBack();
+    }
+  });
+  if (agentList.length === 0) {
+    return h(
+      Box2,
+      { flexDirection: "column" },
+      h(Text2, { bold: true, color: colors.brand }, `  ${fig.horizontal.repeat(3)} Agent Logs`),
+      h(Text2, null, ""),
+      h(Text2, { color: colors.muted }, "  No agent logs yet. Logs appear when agents run."),
+      h(Text2, null, ""),
+      h(FooterBar, { items: [{ key: "esc", label: "Back to serve" }] })
+    );
+  }
+  const pathW = 24;
+  const nameW = 24;
+  const statusW = 10;
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Text2, { dimColor: true }, "Path                 Name                         Credentials  Status        Error"),
-    ...agents.slice(0, 12).map((agent) => h(
-      Text2,
-      { key: agent.localAgentId || agent.relativePath },
-      `${clip(agent.relativePath || ".", 20).padEnd(20)} ${clip(agent.manifestName || agent.manifest?.name || "-", 28).padEnd(28)} ${credentialLabel(agent).padEnd(12)} ${String(agent.status || "-").padEnd(13)} ${clip(agent.errorMessage || "", 36)}`
-    ))
+    h(Text2, { bold: true, color: colors.brand }, `  ${fig.horizontal.repeat(3)} Agent Logs ${fig.horizontal.repeat(20)}`),
+    h(Text2, null, ""),
+    h(Text2, { color: colors.muted }, `  ${"Agent".padEnd(nameW)} ${"Status".padEnd(statusW)} ${"Logs".padEnd(6)} ${"Last event"}`),
+    h(Text2, { color: colors.muted }, `  ${fig.horizontal.repeat(nameW + statusW + 6 + 32)}`),
+    ...agentList.map((agent, i) => {
+      const isActive = i === selectedIndex;
+      const logCountColor = agent.hasErrors ? colors.error : agent.logCount > 0 ? colors.success : colors.muted;
+      const lastEvent = agent.lastLog ? formatAgentLogEntry(agent.lastLog) : "No logs";
+      return h(
+        Text2,
+        { key: agent.path },
+        h(Text2, { color: isActive ? colors.accent : colors.muted }, isActive ? `  ${fig.arrow} ` : "    "),
+        h(Text2, { bold: isActive }, clip(agent.name, nameW - 2).padEnd(nameW)),
+        h(Text2, { color: runtimeStatusColor(agent.status.status) }, `${runtimeStatusIcon(agent.status.status)} ${agent.status.label}`.padEnd(statusW)),
+        h(Text2, { color: logCountColor }, String(agent.logCount).padEnd(6)),
+        h(Text2, { color: colors.muted }, clip(lastEvent, 36))
+      );
+    }),
+    h(Text2, null, ""),
+    h(FooterBar, { items: [
+      { key: "\u2191\u2193", label: "Navigate" },
+      { key: "\u23CE", label: "View logs" },
+      { key: "esc", label: "Back to serve" }
+    ] })
   );
 }
-function LogPane({ logs }) {
+function AgentLogDetail({ relativePath, agentLogs, agentRunState = {}, agents, onBack }) {
+  const logs = agentLogEntries(agentLogs, relativePath);
+  const agent = agents.find((a) => (a.relativePath || ".") === relativePath);
+  const agentName = agent?.manifestName || agent?.manifest?.name || relativePath;
+  const runtime = agent ? agentRuntimeStatus(agent, agentRunState) : { status: agentRunState?.[relativePath]?.status || "unknown", label: agentRunState?.[relativePath]?.status || "offline" };
+  const [scrollOffset, setScrollOffset] = useState5(0);
+  const visibleCount = Math.min(20, Math.max(8, (process.stdout.rows || 24) - 10));
+  useInput2((input, key) => {
+    if (key.escape) {
+      onBack();
+    } else if (key.upArrow) {
+      setScrollOffset((o) => Math.max(0, o - 1));
+    } else if (key.downArrow) {
+      setScrollOffset((o) => Math.min(Math.max(0, logs.length - visibleCount), o + 1));
+    } else if (key.pageDown || input === " ") {
+      setScrollOffset((o) => Math.min(Math.max(0, logs.length - visibleCount), o + visibleCount));
+    } else if (key.pageUp) {
+      setScrollOffset((o) => Math.max(0, o - visibleCount));
+    }
+  });
+  const effectiveOffset = logs.length <= visibleCount ? 0 : scrollOffset >= logs.length - visibleCount - 2 ? Math.max(0, logs.length - visibleCount) : scrollOffset;
+  const visibleLogs = logs.slice(effectiveOffset, effectiveOffset + visibleCount);
+  const visibleRows = groupedLogRows(visibleLogs, logs[effectiveOffset - 1]);
+  const messageWidth = Math.max(50, Math.min((process.stdout.columns || 80) - 18, 120));
   return h(
     Box2,
-    { flexDirection: "column", marginTop: 1 },
-    h(Text2, { bold: true }, "Details"),
-    ...logs.slice(-8).map((event, index) => h(
+    { flexDirection: "column" },
+    h(Text2, { bold: true, color: colors.brand }, `  ${fig.horizontal.repeat(3)} ${agentName}`),
+    h(
       Text2,
-      { key: `${event.type}-${index}`, dimColor: true },
-      `${event.type} ${JSON.stringify(event)}`
-    ))
+      null,
+      h(Text2, { color: colors.muted }, `  ${relativePath} ${fig.dash} ${logs.length} log entries ${fig.dash} `),
+      h(Text2, { color: runtimeStatusColor(runtime.status) }, `${runtimeStatusIcon(runtime.status)} ${runtime.label}`)
+    ),
+    h(Text2, null, ""),
+    logs.length === 0 ? h(Text2, { color: colors.muted }, "  No logs recorded yet for this agent. Logs appear during runs.") : h(
+      Box2,
+      { flexDirection: "column" },
+      ...visibleRows.map((row, i) => {
+        if (row.type === "divider") {
+          return h(
+            Text2,
+            { key: `divider-${effectiveOffset}-${i}`, color: colors.dim },
+            `  ${fig.horizontal.repeat(3)} run ${clip(row.runId, 24)} ${fig.horizontal.repeat(12)}`
+          );
+        }
+        const entry = row.entry;
+        const levelColor = entry.level === "error" ? colors.error : entry.level === "warning" ? colors.warning : entry.level === "debug" ? colors.dim : colors.muted;
+        const timeStr = formatLogTime(entry.timestamp);
+        const icon = entry.eventType === "completion" ? entry.success ? fig.check : fig.cross : entry.eventType === "job_started" ? fig.arrow : entry.eventType === "job_completed" ? entry.success === false ? fig.cross : fig.check : entry.eventType === "step_event" ? fig.arrow : entry.eventType === "progress" ? fig.dotEmpty : entry.eventType === "error" || entry.level === "error" ? fig.cross : fig.dash;
+        const iconColor = entry.eventType === "completion" ? entry.success ? colors.success : colors.error : entry.eventType === "job_started" ? colors.accent : entry.eventType === "job_completed" ? entry.success === false ? colors.error : colors.success : levelColor;
+        return h(
+          Text2,
+          { key: `entry-${effectiveOffset}-${i}` },
+          h(Text2, { color: colors.dim }, `  ${timeStr} `),
+          h(Text2, { color: iconColor }, `${icon} `),
+          h(
+            Text2,
+            { color: entry.level === "error" ? colors.error : colors.text },
+            clip(formatAgentLogEntry(entry), messageWidth)
+          )
+        );
+      }),
+      logs.length > visibleCount && h(
+        Text2,
+        { color: colors.muted },
+        `  ${fig.ellipsis} Showing ${effectiveOffset + 1}-${effectiveOffset + visibleLogs.length} of ${logs.length}`
+      )
+    ),
+    h(Text2, null, ""),
+    h(FooterBar, { items: [
+      { key: "\u2191\u2193", label: "Scroll" },
+      { key: "PgUp/Dn", label: "Page" },
+      { key: "esc", label: "Back to agents" }
+    ] })
   );
 }
+function formatAgentLogEntry(entry) {
+  if (!entry) return "";
+  const type = entry.eventType || "";
+  switch (type) {
+    case "job_started":
+      return entry.message || `Started ${entry.jobType || "run"}`;
+    case "job_completed":
+      return entry.success === false ? `Failed: ${formatEntryError(entry.error) || entry.message || "error"}` : entry.message || "Completed successfully";
+    case "error":
+      return `Error: ${entry.message || formatEntryError(entry.error) || "unknown error"}`;
+    case "log":
+      return entry.message || "";
+    case "progress": {
+      const prog = entry.current != null && entry.total != null ? `${entry.current}/${entry.total}` : "";
+      return `${prog}${entry.message ? ` ${entry.message}` : ""}`.trim() || "progress";
+    }
+    case "completion":
+      if (entry.success) return "Completed successfully";
+      if (entry.error && typeof entry.error === "object") return `Failed: ${entry.error.message || "error"}`;
+      return `Failed: ${entry.error || "unknown error"}`;
+    case "step_event":
+      return `Step: ${entry.stepId || "unknown"}${entry.message ? ` - ${entry.message}` : ""}`;
+    case "step_checkpoint":
+      return `Checkpoint: ${entry.stepId || "unknown"}`;
+    case "step_heartbeat":
+      return `Heartbeat: ${entry.stepId || ""}${entry.message ? ` - ${entry.message}` : ""}`;
+    case "artifact":
+      return `Artifact: ${entry.message || "data"}`;
+    default:
+      return entry.message || type || "event";
+  }
+}
+function groupedLogRows(logs, previousEntry) {
+  const rows = [];
+  let currentRunId = previousEntry?.runId || "";
+  for (const entry of logs) {
+    const runId = entry.runId || "";
+    if (runId && runId !== currentRunId) {
+      rows.push({ type: "divider", runId });
+      currentRunId = runId;
+    }
+    rows.push({ type: "entry", entry });
+  }
+  return rows;
+}
+function formatEntryError(error) {
+  if (!error) return "";
+  if (typeof error === "object") return error.message || "error";
+  return String(error);
+}
+function formatLogTime(timestamp) {
+  if (!timestamp) return "     ";
+  try {
+    const d = new Date(timestamp);
+    const h2 = String(d.getHours()).padStart(2, "0");
+    const m = String(d.getMinutes()).padStart(2, "0");
+    const s = String(d.getSeconds()).padStart(2, "0");
+    return `${h2}:${m}:${s}`;
+  } catch {
+    return "     ";
+  }
+}
 function DoctorScreen({ env: env3, platform: platform2, onBack }) {
   const runtime = runtimeSummary({ env: env3, platform: platform2 });
   const pkg = packageAccessSummary({ env: env3, platform: platform2 });
+  const checks = [
+    { label: "Managed Python", passed: runtime.installed, value: runtime.installed ? "Present" : "Missing" },
+    { label: "Managed Env", passed: runtime.installed, value: runtime.detail },
+    { label: "Package Access", passed: pkg.configured, value: pkg.configured ? `Configured (${pkg.source})` : "Missing" }
+  ];
+  const allPassed = checks.every((c) => c.passed);
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Text2, { bold: true }, "Doctor"),
-    h(Text2, null, `Managed Python: ${runtime.installed ? "present" : "missing"}`),
-    h(Text2, null, `Managed environment: ${runtime.detail}`),
-    h(Text2, null, `Package access: ${pkg.configured ? `configured (${pkg.source})` : "missing"}`),
+    h(Text2, { bold: true }, "  System Health"),
+    h(Text2, null, ""),
+    ...checks.map((check) => h(
+      Text2,
+      { key: check.label },
+      h(Text2, { color: check.passed ? colors.success : colors.error }, `  ${check.passed ? fig.check : fig.cross} `),
+      h(Text2, null, `${check.label.padEnd(18)}${check.value}`)
+    )),
+    h(Text2, null, ""),
+    h(
+      Text2,
+      { color: allPassed ? colors.success : colors.warning, bold: true },
+      allPassed ? `  ${fig.check} All checks passed` : `  ${fig.warning} Some checks need attention`
+    ),
+    h(Text2, null, ""),
     h(SelectInput2, {
-      items: [{ label: "Run plain doctor output", value: "run" }, { label: "Back", value: "back" }],
+      items: [{ label: "Run full doctor output", value: "run" }, { label: "Back", value: "back" }],
       onSelect: async (item) => {
         if (item.value === "back") onBack();
         else doctor({ env: env3, platform: platform2 });
       }
-    })
+    }),
+    h(FooterBar, { items: [{ key: "\u23CE", label: "Select" }, { key: "esc", label: "Back" }] })
   );
 }
 function UpdateScreen({ env: env3, platform: platform2, onBack }) {
@@ -37603,29 +38882,65 @@ function UpdateScreen({ env: env3, platform: platform2, onBack }) {
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Text2, { bold: true }, "Update"),
+    h(Text2, { bold: true }, "  Update Runtime"),
+    h(Text2, null, ""),
     h(SelectInput2, {
-      items: [{ label: "Update managed runtime", value: "run" }, { label: "Back", value: "back" }],
+      items: [{ label: "Update managed runtime & packages", value: "run" }, { label: "Back", value: "back" }],
       onSelect: async (item) => {
         if (item.value === "back") {
           onBack();
           return;
         }
-        setStatus("Updating managed runtime");
+        setStatus(`${fig.dotEmpty} Updating managed runtime...`);
         await setup({ nonInteractive: true, env: env3, platform: platform2 });
-        setStatus("Update finished");
+        setStatus(`${fig.check} Update finished`);
       }
     }),
-    status && h(Text2, null, status)
+    status && h(Text2, { color: status.includes(fig.check) ? colors.success : colors.muted }, `  ${status}`),
+    h(Text2, null, ""),
+    h(FooterBar, { items: [{ key: "\u23CE", label: "Select" }, { key: "esc", label: "Back" }] }),
+    h(BackHint, { onBack })
   );
 }
 function CommandsScreen({ onBack }) {
+  const grouped = [
+    { section: "Getting Started", commands: [
+      { cmd: "vendian login", desc: "Sign in and prepare runtime" },
+      { cmd: "vendian init --output-dir ./agents", desc: "Initialize docs workspace" }
+    ] },
+    { section: "Agent Development", commands: [
+      { cmd: 'vendian create "My Agent" --output-dir .', desc: "Scaffold new agent" },
+      { cmd: "vendian validate ./agents/my-agent --runtime", desc: "Validate manifest" },
+      { cmd: "vendian test ./agents/my-agent --dry-run", desc: "Test locally" },
+      { cmd: "vendian models", desc: "List available models" }
+    ] },
+    { section: "Cloud & Deploy", commands: [
+      { cmd: "vendian cloud local serve --agents-dir .", desc: "Start cloud-connected serve" },
+      { cmd: "vendian login --backend staging", desc: "Connect to staging" }
+    ] },
+    { section: "Maintenance", commands: [
+      { cmd: "vendian doctor", desc: "Check system health" },
+      { cmd: "vendian update", desc: "Update runtime & packages" }
+    ] }
+  ];
   return h(
     Box2,
     { flexDirection: "column" },
-    h(Text2, { bold: true }, "Commands"),
-    ...COMMANDS.map((command) => h(Text2, { key: command }, command)),
-    h(SelectInput2, { items: [{ label: "Back", value: "back" }], onSelect: onBack })
+    h(Text2, { bold: true }, "  Quick Reference"),
+    h(Text2, null, ""),
+    ...grouped.map((group) => [
+      h(Text2, { key: `title-${group.section}`, color: colors.accent, bold: true }, `  ${group.section}`),
+      ...group.commands.map((item) => h(
+        Text2,
+        { key: item.cmd },
+        h(Text2, { color: colors.muted }, "    "),
+        h(Text2, { color: colors.brand }, item.cmd.padEnd(44)),
+        h(Text2, { color: colors.muted }, item.desc)
+      )),
+      h(Text2, { key: `gap-${group.section}` }, "")
+    ]).flat(),
+    h(FooterBar, { items: [{ key: "esc", label: "Back" }] }),
+    h(BackHint, { onBack })
   );
 }
 function CommandPromptScreen({ title, label, initialValue, onSubmit, onBack }) {
@@ -37635,17 +38950,20 @@ function CommandPromptScreen({ title, label, initialValue, onSubmit, onBack }) {
     Box2,
     { flexDirection: "column" },
     h(Text2, { bold: true }, title),
+    h(Text2, null, ""),
     h(TextInput2, {
       value,
       placeholder: label,
       onChange: setValue,
       onSubmit: async (submitted) => {
-        setStatus("Running command");
+        setStatus(`${fig.dotEmpty} Running...`);
         await onSubmit(submitted);
-        setStatus("Command finished");
+        setStatus(`${fig.check} Done`);
       }
     }),
-    status && h(Text2, null, status),
+    status && h(Text2, { color: status.includes(fig.check) ? colors.success : colors.muted }, `  ${status}`),
+    h(Text2, null, ""),
+    h(FooterBar, { items: [{ key: "\u23CE", label: "Submit" }, { key: "esc", label: "Back" }] }),
     h(BackHint, { onBack })
   );
 }
@@ -37653,10 +38971,11 @@ function BackHint({ onBack }) {
   useInput2((input, key) => {
     if (key.escape || input === "\x1B") onBack();
   });
-  return h(Text2, { dimColor: true }, "Esc returns home");
+  return null;
 }
-function attachServeChild(child, setState, setStartupError, onExit) {
+function attachServeChild(child, setState, setStartupError, onExit, logStore = null) {
   let buffer = "";
+  const stderrChunks = [];
   child.stdout.setEncoding("utf8");
   child.stdout.on("data", (chunk) => {
     buffer += chunk;
@@ -37666,6 +38985,10 @@ function attachServeChild(child, setState, setStartupError, onExit) {
       try {
         const event = parseServeEventLine(line);
         if (event) {
+          try {
+            logStore?.append(event);
+          } catch {
+          }
           setState((current) => applyServeEvent(current, event));
         }
       } catch (error) {
@@ -37677,6 +39000,7 @@ function attachServeChild(child, setState, setStartupError, onExit) {
   child.stderr.on("data", (chunk) => {
     const text = String(chunk).trim();
     if (text) {
+      stderrChunks.push(text);
       setState((current) => ({
         ...current,
         logs: [...current.logs, { type: "stderr", message: text }].slice(-200)
@@ -37684,23 +39008,37 @@ function attachServeChild(child, setState, setStartupError, onExit) {
     }
   });
   child.on("error", (error) => setStartupError(errorMessage2(error)));
-  child.on("exit", onExit);
+  child.on("exit", (code, signal) => {
+    try {
+      logStore?.compact();
+    } catch {
+    }
+    const message = serveProcessExitMessage({ stderr: stderrChunks.join("\n"), code, signal });
+    if (message) {
+      setStartupError(message);
+    }
+    onExit({ code, signal, message });
+  });
 }
 function helpText() {
   return [
-    "Vendian CLI",
     "",
-    "Usage:",
-    "  vendian                       Open the interactive shell",
-    "  vendian login                 Sign in and prepare the local runtime",
-    "  vendian doctor                Check local bootstrap health",
-    "  vendian update                Update the managed Vendian CLI/runtime",
-    "  vendian init                  Write current SDK agent docs into a workspace",
-    '  vendian create "My Agent"     Scaffold a new agent from SDK templates',
-    "  vendian <command>             Run a managed Python SDK/cloud command",
+    `  ${fig.arrowUp} VENDIAN CLI v${CLI_VERSION}`,
+    "",
+    "  Usage:",
+    "    vendian                       Open the interactive shell",
+    "    vendian login                 Sign in and prepare the local runtime",
+    "    vendian doctor                Check local bootstrap health",
+    "    vendian update                Update the managed runtime",
+    "    vendian init                  Write SDK agent docs into a workspace",
+    '    vendian create "My Agent"     Scaffold a new agent from templates',
+    "    vendian <command>             Run a managed Python SDK/cloud command",
+    "",
+    "  Examples:",
+    ...COMMANDS.map((command) => `    ${command}`),
     "",
-    "Examples:",
-    ...COMMANDS.map((command) => `  ${command}`)
+    `  Run ${fig.arrowRight} vendian ${fig.arrowRight} to open the interactive TUI`,
+    ""
   ].join("\n");
 }
 function credentialLabel(agent) {