@vendian/cli 0.0.10 → 0.0.11

package/cli-wrapper.mjs

@@ -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(),
@@ -36738,11 +36738,11 @@ function maybeAutoUpdateManagedEnv({
 }
 
 // src/tui.js
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import readlinePromises from "node:readline/promises";
 
 // src/version.js
-var CLI_VERSION = true ? "0.0.10" : 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 NPM_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
@@ -37094,6 +37094,7 @@ function initialServeState() {
     logs: [],
     agentLogs: {},
     // per-agent logs keyed by relativePath
+    agentRunState: {},
     newAgents: [],
     stopped: false,
     jobsRun: 0
@@ -37147,9 +37148,15 @@ 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
     };
   }
@@ -37160,19 +37167,47 @@ function applyServeEvent(state, event) {
       ...next,
       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`
@@ -37188,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")
     };
@@ -37205,9 +37252,21 @@ function applyServeEvent(state, event) {
     };
   }
   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)
+      agentLogs: appendAgentLog(state.agentLogs, event),
+      agentRunState: nextRunState
     };
   }
   return next;
@@ -37232,31 +37291,240 @@ function appendLog(logs, event) {
   return [...logs, event].slice(-200);
 }
 function appendAgentLog(agentLogs, event) {
-  const key = stringValue(event.relativePath || ".");
+  const normalized = serveEventAgentLogEntry(event);
+  if (!normalized) {
+    return agentLogs || {};
+  }
+  const key = normalized.relativePath;
   const existing = agentLogs[key] || [];
-  const entry = {
-    timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    runId: stringValue(event.runId),
-    eventType: stringValue(event.eventType),
-    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
-  };
   return {
     ...agentLogs,
-    [key]: [...existing, entry].slice(-100)
+    [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) => {
@@ -37314,6 +37582,114 @@ function buildLocalServeEventStreamArgs({ agentsDir = "./agents", 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,
@@ -37558,7 +37934,7 @@ function runtimeSummary({ env: env3 = process.env, platform: platform2 = process
   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 {
@@ -37969,11 +38345,26 @@ function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, o
     setStarted(true);
     setStartupError("");
     try {
+      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, ({ message } = {}) => {
         setState((current) => current.stopped ? current : { ...current, stopped: true, activity: message ? "Runtime update required" : "Process exited" });
-      });
+      }, logStore);
     } catch (error) {
       setStartupError(errorMessage2(error));
     }
@@ -38089,8 +38480,9 @@ function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, o
       h(AgentLogViewer, {
         agents: state.agents,
         agentLogs: state.agentLogs,
+        agentRunState: state.agentRunState,
         logMode,
-        onSelectAgent: (path7) => setLogMode(path7),
+        onSelectAgent: (path8) => setLogMode(path8),
         onBack: () => {
           if (logMode === "picker") {
             setLogMode(null);
@@ -38127,7 +38519,7 @@ function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, o
       { 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 }),
+    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,
@@ -38150,7 +38542,7 @@ function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, o
     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, { color: colors.muted }, `  ${fig.dotEmpty} No agents discovered yet.`);
   }
@@ -38162,17 +38554,18 @@ function AgentTable({ agents }) {
   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 path7 = clip(agent.relativePath || ".", pathW);
+    const path8 = clip(agent.relativePath || ".", pathW);
     const name = clip(agent.manifestName || agent.manifest?.name || "-", nameW);
     const creds = credentialLabel(agent);
-    const status = String(agent.status || "-");
-    const statusColor = status === "online" ? colors.success : status === "error" ? colors.error : colors.warning;
-    const statusIcon = status === "online" ? fig.dot : status === "error" ? fig.cross : fig.dotEmpty;
+    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, path7.padEnd(pathW)),
+      h(Text2, null, path8.padEnd(pathW)),
       h(Text2, null, " "),
       h(Text2, null, name.padEnd(nameW)),
       h(Text2, null, " "),
@@ -38191,6 +38584,18 @@ function AgentTable({ agents }) {
     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(
@@ -38204,39 +38609,39 @@ function FooterBar({ items }) {
     ]).flat().filter(Boolean)
   );
 }
-function AgentLogViewer({ agents, agentLogs, logMode, onSelectAgent, onBack }) {
+function AgentLogViewer({ agents, agentLogs, agentRunState, logMode, onSelectAgent, onBack }) {
   if (logMode === "picker") {
-    return h(AgentLogPicker, { agents, agentLogs, onSelectAgent, onBack });
+    return h(AgentLogPicker, { agents, agentLogs, agentRunState, onSelectAgent, onBack });
   }
-  return h(AgentLogDetail, { relativePath: logMode, agentLogs, agents, onBack });
+  return h(AgentLogDetail, { relativePath: logMode, agentLogs, agentRunState, agents, onBack });
 }
-function AgentLogPicker({ agents, agentLogs, onSelectAgent, onBack }) {
+function AgentLogPicker({ agents, agentLogs, agentRunState = {}, onSelectAgent, onBack }) {
   const [selectedIndex, setSelectedIndex] = useState5(0);
   const agentList = agents.map((agent) => {
-    const path7 = agent.relativePath || ".";
-    const logs = agentLogEntries(agentLogs, path7);
+    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: path7,
-      name: agent.manifestName || agent.manifest?.name || path7,
+      path: path8,
+      name: agent.manifestName || agent.manifest?.name || path8,
       logCount: logs.length,
       lastLog,
       hasErrors,
-      status: agent.status || "-"
+      status: agentRuntimeStatus(agent, agentRunState)
     };
   });
   const inventoryPaths = new Set(agentList.map((a) => a.path));
-  for (const path7 of Object.keys(agentLogs || {})) {
-    if (!inventoryPaths.has(path7)) {
-      const logs = agentLogEntries(agentLogs, path7);
+  for (const path8 of Object.keys(agentLogs || {})) {
+    if (!inventoryPaths.has(path8)) {
+      const logs = agentLogEntries(agentLogs, path8);
       agentList.push({
-        path: path7,
-        name: path7,
+        path: path8,
+        name: path8,
         logCount: logs.length,
         lastLog: logs.length > 0 ? logs[logs.length - 1] : null,
         hasErrors: logs.some((l) => l.level === "error"),
-        status: "offline"
+        status: { status: "unknown", label: "offline" }
       });
     }
   }
@@ -38265,14 +38670,15 @@ function AgentLogPicker({ agents, agentLogs, onSelectAgent, onBack }) {
     );
   }
   const pathW = 24;
-  const nameW = 26;
+  const nameW = 24;
+  const statusW = 10;
   return h(
     Box2,
     { flexDirection: "column" },
     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)} ${"Logs".padEnd(6)} ${"Last event"}`),
-    h(Text2, { color: colors.muted }, `  ${fig.horizontal.repeat(nameW + 6 + 30)}`),
+    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;
@@ -38282,6 +38688,7 @@ function AgentLogPicker({ agents, agentLogs, onSelectAgent, onBack }) {
         { 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))
       );
@@ -38294,10 +38701,11 @@ function AgentLogPicker({ agents, agentLogs, onSelectAgent, onBack }) {
     ] })
   );
 }
-function AgentLogDetail({ relativePath, agentLogs, agents, onBack }) {
+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) => {
@@ -38315,29 +38723,44 @@ function AgentLogDetail({ relativePath, agentLogs, agents, onBack }) {
   });
   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" },
     h(Text2, { bold: true, color: colors.brand }, `  ${fig.horizontal.repeat(3)} ${agentName}`),
-    h(Text2, { color: colors.muted }, `  ${relativePath} ${fig.dash} ${logs.length} log entries`),
+    h(
+      Text2,
+      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" },
-      ...visibleLogs.map((entry, i) => {
+      ...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 === "step_event" ? fig.arrow : entry.eventType === "progress" ? fig.dotEmpty : entry.level === "error" ? fig.cross : fig.dash;
-        const iconColor = entry.eventType === "completion" ? entry.success ? colors.success : colors.error : levelColor;
+        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: `${effectiveOffset + i}` },
+          { 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), 60)
+            clip(formatAgentLogEntry(entry), messageWidth)
           )
         );
       }),
@@ -38359,6 +38782,12 @@ 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": {
@@ -38381,6 +38810,24 @@ function formatAgentLogEntry(entry) {
       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 {
@@ -38526,7 +38973,7 @@ function BackHint({ onBack }) {
   });
   return null;
 }
-function attachServeChild(child, setState, setStartupError, onExit) {
+function attachServeChild(child, setState, setStartupError, onExit, logStore = null) {
   let buffer = "";
   const stderrChunks = [];
   child.stdout.setEncoding("utf8");
@@ -38538,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) {
@@ -38558,6 +39009,10 @@ function attachServeChild(child, setState, setStartupError, onExit) {
   });
   child.on("error", (error) => setStartupError(errorMessage2(error)));
   child.on("exit", (code, signal) => {
+    try {
+      logStore?.compact();
+    } catch {
+    }
     const message = serveProcessExitMessage({ stderr: stderrChunks.join("\n"), code, signal });
     if (message) {
       setStartupError(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vendian/cli",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Public Vendian CLI bootstrapper and launcher",
   "license": "UNLICENSED",
   "private": false,