@vendian/cli 0.0.43 → 0.0.45

package/cli-wrapper.mjs

@@ -863,26 +863,27 @@ function initOutputDir(args = []) {
   }
   return ".";
 }
-function resolveWorkspacePath(outputDir, { cwd = process.cwd(), platform = process.platform } = {}) {
+function resolveDocsPath(outputDir, { cwd = process.cwd(), platform = process.platform } = {}) {
   const api = pathApi2(platform);
   const raw = outputDir || ".";
   return api.isAbsolute(raw) ? api.normalize(raw) : api.resolve(cwd, raw);
 }
-function recordAgentDocsWorkspace(outputDir, {
+function recordAgentDocsDir(outputDir, {
   env = process.env,
   platform = process.platform,
   cwd = process.cwd(),
   now = /* @__PURE__ */ new Date()
 } = {}) {
-  const workspacePath = resolveWorkspacePath(outputDir, { cwd, platform });
+  const docsPath = resolveDocsPath(outputDir, { cwd, platform });
   const config = loadConfig(env, platform);
-  const existing = Array.isArray(config[DOC_WORKSPACES_KEY]) ? config[DOC_WORKSPACES_KEY] : [];
-  const workspaces = [workspacePath, ...existing.filter((entry) => entry !== workspacePath)];
+  const existing = agentDocsDirs(config);
+  const dirs = [docsPath, ...existing.filter((entry) => entry !== docsPath)];
   const next = {
     ...config,
-    [DOC_WORKSPACES_KEY]: workspaces,
+    [DOC_DIRS_KEY]: dirs,
     lastAgentDocsInitAt: now.toISOString()
   };
+  delete next[LEGACY_DOC_DIRS_KEY];
   saveConfig(next, env, platform);
   return next;
 }
@@ -890,10 +891,10 @@ function recordForwardedDocsCommand(args, code, options = {}) {
   if (code !== 0 || !commandWritesAgentDocs(args)) {
     return false;
   }
-  recordAgentDocsWorkspace(initOutputDir(args), options);
+  recordAgentDocsDir(initOutputDir(args), options);
   return true;
 }
-function refreshAgentDocsWorkspaces({
+function refreshAgentDocsDirs({
   config,
   venvPath,
   env = process.env,
@@ -902,41 +903,52 @@ function refreshAgentDocsWorkspaces({
   now = /* @__PURE__ */ new Date()
 } = {}) {
   const currentConfig = config || loadConfig(env, platform);
-  const workspaces = Array.isArray(currentConfig[DOC_WORKSPACES_KEY]) ? [...new Set(currentConfig[DOC_WORKSPACES_KEY].filter((entry) => typeof entry === "string" && entry.trim()))] : [];
-  if (workspaces.length === 0) {
+  const dirs = agentDocsDirs(currentConfig);
+  if (dirs.length === 0) {
     saveConfig(currentConfig, env, platform);
     return { config: currentConfig, refreshed: 0, failed: 0 };
   }
   const vendianPath = venvVendian(venvPath, platform);
   let refreshed = 0;
   let failed = 0;
-  for (const workspace of workspaces) {
-    if (!fs7.existsSync(workspace)) {
+  for (const dir of dirs) {
+    if (!fs7.existsSync(dir)) {
       continue;
     }
-    const status = run2(vendianPath, ["init", "--output-dir", workspace, "--yes"]);
+    const status = run2(vendianPath, ["init", "--output-dir", dir, "--yes"]);
     if (status === 0) {
       refreshed += 1;
     } else {
       failed += 1;
-      console.error(`[vendian] Could not refresh SDK docs in ${workspace}`);
+      console.error(`[vendian] Could not refresh SDK docs in ${dir}`);
     }
   }
   const next = {
     ...currentConfig,
-    [DOC_WORKSPACES_KEY]: workspaces,
+    [DOC_DIRS_KEY]: dirs,
     lastAgentDocsRefreshAt: now.toISOString()
   };
+  delete next[LEGACY_DOC_DIRS_KEY];
   saveConfig(next, env, platform);
   return { config: next, refreshed, failed };
 }
-var DOC_WORKSPACES_KEY;
+function agentDocsDirs(config = {}) {
+  return [.../* @__PURE__ */ new Set([
+    ...stringList(config[DOC_DIRS_KEY]),
+    ...stringList(config[LEGACY_DOC_DIRS_KEY])
+  ])];
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim()) : [];
+}
+var DOC_DIRS_KEY, LEGACY_DOC_DIRS_KEY;
 var init_docs = __esm({
   "src/docs.js"() {
     init_config();
     init_paths();
     init_process();
-    DOC_WORKSPACES_KEY = "agentDocWorkspaces";
+    DOC_DIRS_KEY = "agentDocDirs";
+    LEGACY_DOC_DIRS_KEY = ["agentDoc", "Work", "spaces"].join("");
   }
 });
 
@@ -1011,7 +1023,7 @@ async function setup({
   saveConfig(next, env, platform);
   installVendianPackages({ pythonPath, venvPath, config: next, env, platform });
   const updated = { ...next, lastManagedUpdateAt: (/* @__PURE__ */ new Date()).toISOString() };
-  refreshAgentDocsWorkspaces({ config: updated, venvPath, env, platform });
+  refreshAgentDocsDirs({ config: updated, venvPath, env, platform });
   if (!verifyVendianImports(pythonPath)) {
     throw new Error("Vendian packages installed, but import verification failed.");
   }
@@ -1196,8 +1208,8 @@ function findAgentDirectoryCandidates({
   ]);
   for (const root of roots) {
     for (const manifest of findManifestFiles(root, { maxDepth, maxDirs, limit: 250 })) {
-      const workspace = nearestAgentsAncestor(manifest, root);
-      addCandidate(workspace || path4.dirname(manifest));
+      const agentsGroup = nearestAgentsAncestor(manifest, root);
+      addCandidate(agentsGroup || path4.dirname(manifest));
       if (candidates.length >= limit) {
         return candidates.slice(0, limit);
       }
@@ -1459,7 +1471,7 @@ function maybeAutoUpdateManagedEnv({
   load = loadConfig,
   save = saveConfig,
   installPackages = installVendianPackages,
-  refreshDocs = refreshAgentDocsWorkspaces,
+  refreshDocs = refreshAgentDocsDirs,
   now = Date.now(),
   onProgress = null
 } = {}) {
@@ -1509,66 +1521,12 @@ function reportProgress(onProgress, message) {
 init_process();
 init_paths();
 
-// src/workspaces.js
-init_process();
-async function listCloudWorkspaces({
-  env = process.env,
-  platform = process.platform,
-  prepareInvocation = preparePythonVendianInvocation,
-  run: run2 = runCapture,
-  onProgress = null,
-  timeoutMs = 2e4
-} = {}) {
-  const progress = typeof onProgress === "function" ? onProgress : () => {
-  };
-  progress("Checking managed Python runtime");
-  const invocation = await prepareInvocation(["cloud", "collections", "list", "--json"], {
-    env,
-    platform,
-    onProgress: progress,
-    skipAutoUpdate: true
-  });
-  progress("Loading workspaces from Vendian");
-  const result = run2(invocation.command, invocation.args, { env: invocation.env, timeout: timeoutMs });
-  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: stringValue(item.id),
-    name: stringValue(item.name || item.slug || item.id || "Unnamed workspace"),
-    slug: stringValue(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 stringValue(value) {
-  return value == null ? "" : String(value).trim();
-}
-
 // src/serve-events.js
 function initialServeState() {
   return {
     connected: false,
     daemonId: "",
     cliSessionId: "",
-    collectionId: "",
     agents: [],
     activity: "Starting local daemon",
     currentJob: null,
@@ -1616,15 +1574,12 @@ function applyServeEvent(state, event) {
     ...state,
     logs: appendLog(state.logs, event)
   };
-  if (event.type === "workspace_resolved") {
-    return { ...next, collectionId: stringValue2(event.collectionId), activity: "Workspace resolved" };
-  }
   if (event.type === "daemon_registered") {
     return {
       ...next,
       connected: true,
-      daemonId: stringValue2(event.daemonId),
-      cliSessionId: stringValue2(event.cliSessionId),
+      daemonId: stringValue(event.daemonId),
+      cliSessionId: stringValue(event.cliSessionId),
       activity: "Daemon registered"
     };
   }
@@ -1644,7 +1599,7 @@ function applyServeEvent(state, event) {
     };
   }
   if (event.type === "daemon_wake_received") {
-    const sourceType = stringValue2(event.sourceEventType || "backend wake");
+    const sourceType = stringValue(event.sourceEventType || "backend wake");
     return {
       ...next,
       activity: `Wake received: ${sourceType}`
@@ -1659,17 +1614,17 @@ function applyServeEvent(state, event) {
   if (event.type === "dispatch_job_received") {
     return {
       ...next,
-      activity: `Dispatch received for run ${stringValue2(event.runId || event.sessionId || "unknown")}`
+      activity: `Dispatch received for run ${stringValue(event.runId || event.sessionId || "unknown")}`
     };
   }
   if (event.type === "dispatch_job_acked") {
     return {
       ...next,
-      activity: `Dispatch acknowledged for run ${stringValue2(event.runId || event.sessionId || "unknown")}`
+      activity: `Dispatch acknowledged for run ${stringValue(event.runId || event.sessionId || "unknown")}`
     };
   }
   if (event.type === "daemon_stderr") {
-    const message = stringValue2(event.message || event.stderr || "Daemon wrote to stderr");
+    const message = stringValue(event.message || event.stderr || "Daemon wrote to stderr");
     return {
       ...next,
       activity: `Daemon stderr: ${message}`,
@@ -1714,14 +1669,14 @@ function applyServeEvent(state, event) {
   if (event.type === "agent_prepare_progress") {
     const relativePath = agentLabel(event);
     const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-    const message = stringValue2(event.message || event.stage || "Preparing agent");
+    const message = stringValue(event.message || event.stage || "Preparing agent");
     return {
       ...next,
       agentLogs: appendAgentLog(state.agentLogs, event),
       agentRunState: setAgentRunState(state.agentRunState, relativePath, {
         status: "preparing",
         lastEventAt: timestamp,
-        progressStage: stringValue2(event.stage),
+        progressStage: stringValue(event.stage),
         progressMessage: message
       }),
       activity: `${relativePath}: ${message}`
@@ -1733,11 +1688,11 @@ function applyServeEvent(state, event) {
     const runState = isError ? setAgentRunState(state.agentRunState, agentLabel(event), {
       status: "error",
       lastEventAt: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-      errorMessage: stringValue2(event.error || event.errorMessage || "Agent setup failed")
+      errorMessage: stringValue(event.error || event.errorMessage || "Agent setup failed")
     }) : isDisabled ? setAgentRunState(state.agentRunState, agentLabel(event), {
       status: "disabled",
       lastEventAt: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-      disabledReason: stringValue2(event.disabledReason || event.warning || "System dependency not met"),
+      disabledReason: stringValue(event.disabledReason || event.warning || "System dependency not met"),
       resolutionHints: Array.isArray(event.resolutionHints) ? event.resolutionHints : []
     }) : setAgentRunState(state.agentRunState, agentLabel(event), {
       status: "ready",
@@ -1773,8 +1728,8 @@ function applyServeEvent(state, event) {
       agentLogs: appendAgentLog(state.agentLogs, event),
       agentRunState: setAgentRunState(state.agentRunState, relativePath, {
         status: "running",
-        runId: stringValue2(event.runId || event.deployRequestId),
-        jobType: stringValue2(event.jobType || "run"),
+        runId: stringValue(event.runId || event.deployRequestId),
+        jobType: stringValue(event.jobType || "run"),
         startedAt: timestamp,
         completedAt: null,
         lastEventAt: timestamp,
@@ -1788,7 +1743,7 @@ function applyServeEvent(state, event) {
     const relativePath = agentLabel(event);
     const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
     const success = event.success !== false;
-    const runId = stringValue2(event.runId || event.deployRequestId);
+    const runId = stringValue(event.runId || event.deployRequestId);
     const previous = (state.agentRunState || {})[relativePath];
     const effectiveSuccess = success && !(previous?.status === "error" && previous?.runId === runId);
     return {
@@ -1797,10 +1752,10 @@ function applyServeEvent(state, event) {
       agentRunState: setAgentRunState(state.agentRunState, relativePath, {
         status: effectiveSuccess ? "completed" : "error",
         runId,
-        jobType: stringValue2(event.jobType || "run"),
+        jobType: stringValue(event.jobType || "run"),
         completedAt: timestamp,
         lastEventAt: timestamp,
-        errorMessage: effectiveSuccess ? null : previous?.errorMessage || stringValue2(event.error || "Job failed")
+        errorMessage: effectiveSuccess ? null : previous?.errorMessage || stringValue(event.error || "Job failed")
       }),
       jobsRun: state.jobsRun + 1,
       currentJob: null,
@@ -1808,13 +1763,13 @@ function applyServeEvent(state, event) {
     };
   }
   if (event.type === "backend_connection_lost") {
-    return { ...next, connected: false, activity: `Connection lost during ${stringValue2(event.activity)}`, retry: event };
+    return { ...next, connected: false, activity: `Connection lost during ${stringValue(event.activity)}`, retry: event };
   }
   if (event.type === "backend_connection_restored") {
     return { ...next, connected: true, activity: "Backend connection restored", retry: null };
   }
   if (event.type === "retry_scheduled") {
-    return { ...next, retry: event, activity: `Retrying ${stringValue2(event.activity)} in ${formatSeconds(event.delaySeconds)}` };
+    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) : "";
@@ -1825,11 +1780,11 @@ function applyServeEvent(state, event) {
       agentLogs: hasAgentScope ? appendAgentLog(state.agentLogs, event) : state.agentLogs,
       agentRunState: hasAgentScope ? setAgentRunState(state.agentRunState, relativePath, {
         status: "error",
-        runId: stringValue2(event.runId || event.deployRequestId),
-        jobType: stringValue2(event.jobType || "run"),
+        runId: stringValue(event.runId || event.deployRequestId),
+        jobType: stringValue(event.jobType || "run"),
         completedAt: timestamp,
         lastEventAt: timestamp,
-        errorMessage: stringValue2(event.error || event.code || "Unknown error")
+        errorMessage: stringValue(event.error || event.code || "Unknown error")
       }) : state.agentRunState,
       activity: "Error",
       errors: appendError(state.errors, jobLabel(event), event.error || event.code || "Unknown error")
@@ -1847,8 +1802,8 @@ function applyServeEvent(state, event) {
   }
   if (event.type === "process_exit" || event.type === "daemon_exit") {
     const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-    const message = stringValue2(event.message || processExitMessage(event));
-    const relativePath = stringValue2(event.relativePath || "");
+    const message = stringValue(event.message || processExitMessage(event));
+    const relativePath = stringValue(event.relativePath || "");
     const runState = failRunningAgents(state.agentRunState, message, timestamp, relativePath);
     return {
       ...next,
@@ -1903,7 +1858,7 @@ function mergeAgentLogRecords(agentLogs, records = []) {
   let next = agentLogs || {};
   for (const record of records) {
     if (!record || typeof record !== "object") continue;
-    const relativePath = stringValue2(record.relativePath || ".");
+    const relativePath = stringValue(record.relativePath || ".");
     const entry = record.entry && typeof record.entry === "object" ? record.entry : record;
     const existing = next[relativePath] || [];
     next = {
@@ -1918,13 +1873,13 @@ function agentRunStateFromLogs(agentLogs, { includeRunning = true } = {}) {
   for (const [relativePath, entries] of Object.entries(agentLogs || {})) {
     for (const entry of entries || []) {
       const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-      const runId = stringValue2(entry.runId);
+      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 ? stringValue2(entry.jobType) : current.jobType,
+          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
           startedAt: timestamp,
           lastEventAt: timestamp
         });
@@ -1935,10 +1890,10 @@ function agentRunStateFromLogs(agentLogs, { includeRunning = true } = {}) {
         next = setAgentRunState(next, relativePath, {
           status: failed ? "error" : "completed",
           runId,
-          jobType: entry.jobType ? stringValue2(entry.jobType) : current.jobType,
+          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
           completedAt: timestamp,
           lastEventAt: timestamp,
-          errorMessage: failed ? formatErrorMessage(entry.error) || current.errorMessage || stringValue2(entry.message || "Job failed") : null
+          errorMessage: failed ? formatErrorMessage(entry.error) || current.errorMessage || stringValue(entry.message || "Job failed") : null
         });
         continue;
       }
@@ -1946,10 +1901,10 @@ function agentRunStateFromLogs(agentLogs, { includeRunning = true } = {}) {
         next = setAgentRunState(next, relativePath, {
           status: "error",
           runId,
-          jobType: entry.jobType ? stringValue2(entry.jobType) : current.jobType,
+          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
           completedAt: timestamp,
           lastEventAt: timestamp,
-          errorMessage: formatErrorMessage(entry.error) || stringValue2(entry.message || "Job failed")
+          errorMessage: formatErrorMessage(entry.error) || stringValue(entry.message || "Job failed")
         });
         continue;
       }
@@ -1967,34 +1922,34 @@ function serveEventAgentLogEntry(event) {
   if (!event || typeof event !== "object") {
     return null;
   }
-  const type = stringValue2(event.type);
-  const relativePath = stringValue2(event.relativePath || event.path || ".");
+  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: stringValue2(event.runId),
-        eventType: stringValue2(event.eventType || "log"),
-        level: stringValue2(event.level || "info"),
-        message: stringValue2(event.message),
-        stepId: event.stepId ? stringValue2(event.stepId) : null,
+        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 ? stringValue2(event.jobType) : null
+        jobType: event.jobType ? stringValue(event.jobType) : null
       }
     };
   }
   if (type === "job_started") {
-    const jobType = stringValue2(event.jobType || "run");
+    const jobType = stringValue(event.jobType || "run");
     return {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue2(event.runId || event.deployRequestId),
+        runId: stringValue(event.runId || event.deployRequestId),
         eventType: "job_started",
         level: "info",
         message: `Started ${jobType}`,
@@ -2009,15 +1964,15 @@ function serveEventAgentLogEntry(event) {
   }
   if (type === "job_completed") {
     const success = event.success !== false;
-    const jobType = stringValue2(event.jobType || "run");
+    const jobType = stringValue(event.jobType || "run");
     return {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue2(event.runId || event.deployRequestId),
+        runId: stringValue(event.runId || event.deployRequestId),
         eventType: "job_completed",
         level: success ? "info" : "error",
-        message: success ? "Completed successfully" : stringValue2(event.error || "Failed"),
+        message: success ? "Completed successfully" : stringValue(event.error || "Failed"),
         stepId: null,
         current: null,
         total: null,
@@ -2032,16 +1987,16 @@ function serveEventAgentLogEntry(event) {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue2(event.runId || event.deployRequestId),
+        runId: stringValue(event.runId || event.deployRequestId),
         eventType: "error",
         level: "error",
-        message: stringValue2(event.error || event.code || "Unknown 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 ? stringValue2(event.jobType) : null
+        jobType: event.jobType ? stringValue(event.jobType) : null
       }
     };
   }
@@ -2055,7 +2010,7 @@ function serveEventAgentLogEntry(event) {
         eventType: type,
         level: event.status === "error" ? "error" : "info",
         message: agentPrepareLogMessage(event),
-        stepId: stringValue2(event.stage || type),
+        stepId: stringValue(event.stage || type),
         current: null,
         total: null,
         success,
@@ -2065,12 +2020,12 @@ function serveEventAgentLogEntry(event) {
     };
   }
   if (type === "process_exit" || type === "daemon_exit") {
-    const message = stringValue2(event.message || processExitMessage(event));
+    const message = stringValue(event.message || processExitMessage(event));
     return {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue2(event.runId || event.sessionId || "daemon"),
+        runId: stringValue(event.runId || event.sessionId || "daemon"),
         eventType: type,
         level: "error",
         message,
@@ -2084,16 +2039,16 @@ function serveEventAgentLogEntry(event) {
           signal: event.signal ?? null,
           stderrTail: event.stderrTail ?? null
         },
-        jobType: event.jobType ? stringValue2(event.jobType) : null
+        jobType: event.jobType ? stringValue(event.jobType) : null
       }
     };
   }
   return null;
 }
 function agentRuntimeStatus(agent, agentRunState = {}) {
-  const path10 = stringValue2(agent?.relativePath || ".");
+  const path10 = stringValue(agent?.relativePath || ".");
   const run2 = (agentRunState || {})[path10];
-  const inventoryStatus = stringValue2(agent?.status);
+  const inventoryStatus = stringValue(agent?.status);
   if (run2?.status === "running") {
     return { status: "running", label: "running", run: run2 };
   }
@@ -2121,28 +2076,26 @@ function agentRuntimeStatus(agent, agentRunState = {}) {
   return { status: inventoryStatus || "unknown", label: inventoryStatus || "unknown", run: run2 };
 }
 function appendError(errors, scope, message) {
-  return [...errors, { scope, message: stringValue2(message) }].slice(-20);
+  return [...errors, { scope, message: stringValue(message) }].slice(-20);
 }
 function serveDebugEntry(event) {
   if (!event || typeof event !== "object") return null;
-  const type = stringValue2(event.type);
+  const type = stringValue(event.type);
   const timestamp = event.timestamp || event.occurredAt || (/* @__PURE__ */ new Date()).toISOString();
   const base = { timestamp, eventType: type, level: debugLevel(event) };
   switch (type) {
-    case "workspace_resolved":
-      return { ...base, message: `workspace resolved collection=${stringValue2(event.collectionId || "unknown")}` };
     case "daemon_registered":
       return { ...base, message: `daemon registered daemon=${shortId(event.daemonId)} cli=${shortId(event.cliSessionId)}` };
     case "daemon_event_stream_connected":
       return { ...base, message: `daemon event stream connected daemon=${shortId(event.daemonId)}` };
     case "daemon_event_stream_lost":
-      return { ...base, level: "warn", message: `daemon event stream lost retry=${formatSeconds(event.retryInSeconds)} error=${stringValue2(event.error || "unknown")}` };
+      return { ...base, level: "warn", message: `daemon event stream lost retry=${formatSeconds(event.retryInSeconds)} error=${stringValue(event.error || "unknown")}` };
     case "daemon_wake_received":
       return {
         ...base,
         message: [
-          `wake received source=${stringValue2(event.sourceEventType || "backend")}`,
-          event.eventType ? `event=${stringValue2(event.eventType)}` : "",
+          `wake received source=${stringValue(event.sourceEventType || "backend")}`,
+          event.eventType ? `event=${stringValue(event.eventType)}` : "",
           event.sessionId ? `session=${shortId(event.sessionId)}` : "",
           event.runId ? `run=${shortId(event.runId)}` : "",
           event.localAgentRowId ? `agentRow=${shortId(event.localAgentRowId)}` : ""
@@ -2165,7 +2118,7 @@ function serveDebugEntry(event) {
         message: `dispatch acked delivery=${shortId(event.deliveryId)} run=${shortId(event.runId || event.sessionId)} attempt=${shortId(event.attemptId)}`
       };
     case "job_started":
-      return { ...base, message: `job started type=${stringValue2(event.jobType || "run")} run=${shortId(event.runId || event.sessionId || event.deployRequestId || event.testRunId)}` };
+      return { ...base, message: `job started type=${stringValue(event.jobType || "run")} run=${shortId(event.runId || event.sessionId || event.deployRequestId || event.testRunId)}` };
     case "job_completed":
       return {
         ...base,
@@ -2173,18 +2126,18 @@ function serveDebugEntry(event) {
         message: `job completed success=${event.success !== false} run=${shortId(event.runId || event.sessionId || event.deployRequestId || event.testRunId)}${event.error ? ` error=${formatErrorMessage(event.error)}` : ""}`
       };
     case "backend_connection_lost":
-      return { ...base, level: "warn", message: `backend connection lost activity=${stringValue2(event.activity)} error=${stringValue2(event.error)}` };
+      return { ...base, level: "warn", message: `backend connection lost activity=${stringValue(event.activity)} error=${stringValue(event.error)}` };
     case "backend_connection_restored":
-      return { ...base, message: `backend connection restored activity=${stringValue2(event.activity)}` };
+      return { ...base, message: `backend connection restored activity=${stringValue(event.activity)}` };
     case "retry_scheduled":
-      return { ...base, level: "warn", message: `retry scheduled activity=${stringValue2(event.activity)} delay=${formatSeconds(event.delaySeconds)}` };
+      return { ...base, level: "warn", message: `retry scheduled activity=${stringValue(event.activity)} delay=${formatSeconds(event.delaySeconds)}` };
     case "daemon_stderr":
-      return { ...base, level: looksLikeError(event.message || event.stderr) ? "error" : "warn", message: `stderr ${stringValue2(event.message || event.stderr)}` };
+      return { ...base, level: looksLikeError(event.message || event.stderr) ? "error" : "warn", message: `stderr ${stringValue(event.message || event.stderr)}` };
     case "error":
-      return { ...base, level: "error", message: `error scope=${stringValue2(event.relativePath || event.path || "daemon")} ${stringValue2(event.error || event.code || "unknown")}` };
+      return { ...base, level: "error", message: `error scope=${stringValue(event.relativePath || event.path || "daemon")} ${stringValue(event.error || event.code || "unknown")}` };
     case "process_exit":
     case "daemon_exit":
-      return { ...base, level: "error", message: stringValue2(event.message || processExitMessage(event)) };
+      return { ...base, level: "error", message: stringValue(event.message || processExitMessage(event)) };
     case "stopped":
       return { ...base, message: `stopped jobsRun=${Number(event.jobsRun ?? 0)}` };
     default:
@@ -2192,7 +2145,7 @@ function serveDebugEntry(event) {
   }
 }
 function debugLevel(event) {
-  if (event?.level) return stringValue2(event.level);
+  if (event?.level) return stringValue(event.level);
   if (event?.type === "error" || event?.type === "process_exit" || event?.type === "daemon_exit") return "error";
   return "info";
 }
@@ -2200,14 +2153,14 @@ function boolText(value) {
   return value ? "yes" : "no";
 }
 function shortId(value) {
-  const text = stringValue2(value);
+  const text = stringValue(value);
   return text ? text.slice(0, 8) : "unknown";
 }
 function looksLikeError(value) {
-  return /(error|exception|traceback|failed|fatal|denied|unauthorized|timeout)/i.test(stringValue2(value));
+  return /(error|exception|traceback|failed|fatal|denied|unauthorized|timeout)/i.test(stringValue(value));
 }
 function setAgentRunState(agentRunState, relativePath, patch) {
-  const key = stringValue2(relativePath || ".");
+  const key = stringValue(relativePath || ".");
   return {
     ...agentRunState || {},
     [key]: {
@@ -2259,19 +2212,19 @@ function appendProcessExitAgentLogs(agentLogs, event, agentRunState, relativePat
 function reconcileInventoryRunState(agentRunState, agents, timestamp) {
   let next = agentRunState || {};
   for (const agent of agents || []) {
-    const path10 = stringValue2(agent?.relativePath || ".");
+    const path10 = stringValue(agent?.relativePath || ".");
     const current = next[path10];
     if (agent?.status === "error") {
       next = setAgentRunState(next, path10, {
         status: "error",
         lastEventAt: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        errorMessage: stringValue2(agent.errorMessage || agent.error || "Agent setup failed")
+        errorMessage: stringValue(agent.errorMessage || agent.error || "Agent setup failed")
       });
     } else if (agent?.status === "disabled") {
       next = setAgentRunState(next, path10, {
         status: "disabled",
         lastEventAt: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        disabledReason: stringValue2(agent.disabledReason || "System dependency not met locally"),
+        disabledReason: stringValue(agent.disabledReason || "System dependency not met locally"),
         resolutionHints: Array.isArray(agent.resolutionHints) ? agent.resolutionHints : []
       });
     } else if (agent?.status === "online" && ["preparing", "error", "disabled"].includes(current?.status) && !current?.runId) {
@@ -2291,22 +2244,22 @@ function reconcileInventoryRunState(agentRunState, agents, timestamp) {
 function normalizeStoredAgentLogEntry(entry) {
   return {
     timestamp: entry.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    runId: stringValue2(entry.runId),
-    eventType: stringValue2(entry.eventType || "log"),
-    level: stringValue2(entry.level || "info"),
-    message: stringValue2(entry.message),
-    stepId: entry.stepId ? stringValue2(entry.stepId) : null,
+    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 ? stringValue2(entry.jobType) : null
+    jobType: entry.jobType ? stringValue(entry.jobType) : null
   };
 }
 function formatErrorMessage(error) {
   if (!error) return null;
-  if (typeof error === "object") return stringValue2(error.message || "error");
-  return stringValue2(error);
+  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));
@@ -2319,15 +2272,15 @@ function agentKey(agent) {
   if (!agent || typeof agent !== "object") {
     return "";
   }
-  return stringValue2(agent.localAgentId || agent.relativePath || agent.path || agent.manifestName || agent.id);
+  return stringValue(agent.localAgentId || agent.relativePath || agent.path || agent.manifestName || agent.id);
 }
 function agentLabel(event) {
-  return stringValue2(event.relativePath || event.path || ".");
+  return stringValue(event.relativePath || event.path || ".");
 }
 function jobLabel(event) {
-  return stringValue2(event.runId || event.deployRequestId || event.relativePath || event.jobType || "job");
+  return stringValue(event.runId || event.deployRequestId || event.relativePath || event.jobType || "job");
 }
-function stringValue2(value) {
+function stringValue(value) {
   return value == null ? "" : String(value);
 }
 function processExitMessage(event) {
@@ -2344,11 +2297,11 @@ function agentPrepareLogMessage(event) {
     return "Preparing agent";
   }
   if (event.type === "agent_prepare_completed") {
-    if (event.status === "error") return stringValue2(event.error || event.errorMessage || "Agent setup failed");
-    if (event.status === "disabled") return stringValue2(event.warning || event.disabledReason || "Agent disabled locally");
+    if (event.status === "error") return stringValue(event.error || event.errorMessage || "Agent setup failed");
+    if (event.status === "disabled") return stringValue(event.warning || event.disabledReason || "Agent disabled locally");
     return "Agent ready";
   }
-  return stringValue2(event.message || event.stage || "Preparing agent");
+  return stringValue(event.message || event.stage || "Preparing agent");
 }
 function textTail(value, limit = 800) {
   const text = String(value || "").trim().replace(/\s+/g, " ");
@@ -2368,11 +2321,10 @@ var MAX_EVENTS = 5e3;
 var MAX_RUNS = 50;
 function createServeLogStore({
   agentsDir: agentsDir2 = "./agents",
-  collectionId: collectionId2 = "",
   env = process.env,
   platform = process.platform
 } = {}) {
-  const file = serveLogFilePath({ agentsDir: agentsDir2, collectionId: collectionId2, env, platform });
+  const file = serveLogFilePath({ agentsDir: agentsDir2, env, platform });
   let appendCount = 0;
   return {
     file,
@@ -2387,7 +2339,6 @@ function createServeLogStore({
       fs10.mkdirSync(path7.dirname(file), { recursive: true });
       const record = {
         version: 1,
-        collectionId: collectionId2 || "",
         agentsDir: String(agentsDir2 || "./agents"),
         relativePath: normalized.relativePath,
         entry: normalized.entry
@@ -2407,14 +2358,13 @@ function createServeLogStore({
 }
 function serveLogFilePath({
   agentsDir: agentsDir2 = "./agents",
-  collectionId: collectionId2 = "",
   env = process.env,
   platform = process.platform
 } = {}) {
   const root = vendianHome(env, platform);
   const resolvedAgentsDir = path7.resolve(String(agentsDir2 || "./agents"));
-  const hash = crypto2.createHash("sha256").update(`${collectionId2 || "default"}\0${resolvedAgentsDir}`).digest("hex").slice(0, 16);
-  return path7.join(root, "serve-logs", `${safePathPart(collectionId2 || "default")}-${hash}.jsonl`);
+  const hash = crypto2.createHash("sha256").update(resolvedAgentsDir).digest("hex").slice(0, 16);
+  return path7.join(root, "serve-logs", `default-${hash}.jsonl`);
 }
 function readServeLogRecords(file) {
   if (!file || !fs10.existsSync(file)) {
@@ -2464,28 +2414,24 @@ function trimServeLogRecords(records) {
     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/serve-process.js
 import { spawn as spawn2 } from "node:child_process";
 async function spawnLocalServeEventStream({
   agentsDir: agentsDir2 = "./agents",
-  collectionId: collectionId2 = "",
   env = process.env,
   platform = process.platform,
   onProgress = null
 } = {}) {
-  const invocation = await preparePythonVendianInvocation(buildLocalServeEventStreamArgs({ agentsDir: agentsDir2, collectionId: collectionId2 }), { env, platform, onProgress });
+  const invocation = await preparePythonVendianInvocation(buildLocalServeEventStreamArgs({ agentsDir: agentsDir2 }), { env, platform, onProgress });
   return spawn2(invocation.command, invocation.args, {
     env: invocation.env,
     stdio: ["ignore", "pipe", "pipe"],
     shell: false
   });
 }
-function buildLocalServeEventStreamArgs({ agentsDir: agentsDir2 = "./agents", collectionId: collectionId2 = "" } = {}) {
-  const args = [
+function buildLocalServeEventStreamArgs({ agentsDir: agentsDir2 = "./agents" } = {}) {
+  return [
     "cloud",
     "local",
     "serve",
@@ -2493,14 +2439,10 @@ function buildLocalServeEventStreamArgs({ agentsDir: agentsDir2 = "./agents", co
     agentsDir2 || "./agents",
     "--event-stream"
   ];
-  if (collectionId2) {
-    args.push("--collection-id", collectionId2);
-  }
-  return args;
 }
 
 // src/version.js
-var CLI_VERSION = true ? "0.0.43" : process.env.npm_package_version || "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.45" : process.env.npm_package_version || "0.0.0-dev";
 
 // src/dev-server.js
 var __dirname = path8.dirname(fileURLToPath(import.meta.url));
@@ -2512,7 +2454,6 @@ var serveLogs = [];
 var logStore = null;
 var agentsDir = "";
 var activeServeAgentsDir = "";
-var collectionId = "";
 var activeAuthLogin = null;
 async function startDevServer({
   port = 3859,
@@ -2621,8 +2562,6 @@ async function handleApi(req, res, pathname, parsed) {
           return apiServeState(req, res);
         case "/api/auth":
           return apiAuth(req, res);
-        case "/api/workspaces":
-          return await apiWorkspaces(req, res);
         default:
           return jsonResponse(res, { error: "not found" }, 404);
       }
@@ -2657,7 +2596,6 @@ function apiStatus(req, res) {
     serving,
     agentsDir,
     serveAgentsDir: serving ? activeServeAgentsDir || agentsDir : "",
-    collectionId,
     connected: serveState.connected,
     activity: serveState.activity,
     agentCount: serveState.agents.length,
@@ -2785,10 +2723,6 @@ function apiAuth(req, res) {
     backends
   });
 }
-async function apiWorkspaces(req, res) {
-  const result = await listCloudWorkspaces({ timeoutMs: 15e3 });
-  jsonResponse(res, result);
-}
 async function apiAuthSwitch(req, res, body) {
   const backend = body.backend;
   if (!backend || !BACKEND_TARGETS[backend]) {
@@ -2875,41 +2809,34 @@ async function apiValidate(req, res, body) {
 }
 function resolveServeStartTarget(body = {}, current = {}) {
   const targetDir = body.agentsDir || current.agentsDir || "";
-  const targetCollection = body.collectionId || current.collectionId || "";
-  if (!targetCollection) {
-    return { ok: false, error: "Choose a workspace before starting local serve." };
-  }
-  return { ok: true, agentsDir: targetDir, collectionId: targetCollection };
+  return { ok: true, agentsDir: targetDir };
 }
 function devServerStateAfterServeStart(current = {}, target = {}) {
   return {
     agentsDir: current.agentsDir || "",
-    activeServeAgentsDir: target.agentsDir || current.agentsDir || "",
-    collectionId: target.collectionId || current.collectionId || ""
+    activeServeAgentsDir: target.agentsDir || current.agentsDir || ""
   };
 }
 async function apiServeStart(req, res, body) {
   if (childProcessIsRunning(serveChild)) {
     return jsonResponse(res, { ok: false, error: "Already serving" });
   }
-  const target = resolveServeStartTarget(body, { agentsDir, collectionId });
+  const target = resolveServeStartTarget(body, { agentsDir });
   if (!target.ok) {
     return jsonResponse(res, target, 400);
   }
   try {
     const targetDir = target.agentsDir;
-    const targetCollection = target.collectionId;
     const invocation = await preparePythonVendianInvocation(
-      buildLocalServeEventStreamArgs({ agentsDir: targetDir, collectionId: targetCollection }),
+      buildLocalServeEventStreamArgs({ agentsDir: targetDir }),
       { onProgress: null }
     );
-    const nextState = devServerStateAfterServeStart({ agentsDir, collectionId }, target);
+    const nextState = devServerStateAfterServeStart({ agentsDir }, target);
     agentsDir = nextState.agentsDir;
     activeServeAgentsDir = nextState.activeServeAgentsDir;
-    collectionId = nextState.collectionId;
     serveState = initialServeState();
     serveLogs = [];
-    logStore = createServeLogStore({ agentsDir: activeServeAgentsDir, collectionId });
+    logStore = createServeLogStore({ agentsDir: activeServeAgentsDir });
     serveChild = spawn3(invocation.command, invocation.args, {
       env: invocation.env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -3392,7 +3319,6 @@ var HOME_ACTIONS = [
   { value: "serve", label: "Serve my agents", desc: "Start agents and stream their logs" },
   { value: "connect", label: "Login / Switch", desc: "Sign in or switch to a different environment" },
   { value: "create", label: "Create Agent", desc: "Build a new agent from a template" },
-  { value: "run", label: "Run once", desc: "Execute one agent immediately" },
   { value: "commands", label: "Commands", desc: "Show all CLI commands" },
   { value: "exit", label: "Exit", desc: "" }
 ];
@@ -3463,7 +3389,7 @@ async function connectCustomUrl({ env, platform }) {
 var COMMAND_GROUPS = [
   { section: "Getting started", commands: [
     { cmd: "vendian login", desc: "Sign in and set up your computer" },
-    { cmd: "vendian init --output-dir ./agents", desc: "Set up a docs workspace" }
+    { cmd: "vendian init --output-dir ./agents", desc: "Set up SDK docs" }
   ] },
   { section: "Building agents", commands: [
     { cmd: 'vendian create "My Agent" --output-dir .', desc: "Create a new agent" },
@@ -3472,14 +3398,13 @@ var COMMAND_GROUPS = [
   ] },
   { section: "Running agents", commands: [
     { cmd: "vendian dev", desc: "Open the dev UI in your browser" },
-    { cmd: "vendian cloud local run --collection-id ID --path . --input-json '{}'", desc: "Run one agent" },
     { cmd: "vendian cloud local serve --agents-dir .", desc: "Start agents" },
     { cmd: "vendian login --backend staging", desc: "Sign in to staging" }
   ] },
   { section: "Syncing & deploying", commands: [
-    { cmd: "vendian cloud local push --collection-id ID --project-id PID", desc: "Push code to project repo" },
-    { cmd: "vendian cloud local push --branch feature/x --from dev", desc: "Push to a new branch" },
-    { cmd: "vendian cloud local deploy --collection-id ID --project-id PID", desc: "Deploy to cloud" }
+    { cmd: "vendian cloud suite status --remote", desc: "Check source-set status" },
+    { cmd: "vendian cloud suite push --wait", desc: "Push selected source-set code" },
+    { cmd: "vendian cloud suite deploy --environment staging", desc: "Deploy a source set" }
   ] },
   { section: "Maintenance", commands: [
     { cmd: "vendian doctor", desc: "Check if everything is set up" },
@@ -3554,84 +3479,6 @@ async function pickAgentsFromFolder({ env, platform, candidate }) {
   if (idx === 0) return { agentsDir: candidate.path };
   return { agentsDir: named[idx - 1].path };
 }
-async function pickSingleAgentToRun({ env, platform, candidates }) {
-  if (candidates.length === 0) {
-    clearScreen();
-    print("");
-    print(col.yellow("  Couldn't find any agents."));
-    const input = await ask("Agent folder", "./agents/my-agent");
-    if (!input) return null;
-    return { path: input, displayName: friendlyName(path9.basename(input) || "Agent") };
-  }
-  const agents = candidates.flatMap((candidate) => {
-    const folders = findAgentFolders(candidate.absolutePath);
-    if (folders.length > 0) {
-      return folders.map((folder) => ({
-        path: folder.path,
-        displayName: readManifestName(folder.absolutePath) || friendlyName(folder.name || path9.basename(folder.path))
-      }));
-    }
-    return [{
-      path: candidate.path,
-      displayName: readManifestName(candidate.absolutePath) || friendlyName(path9.basename(candidate.absolutePath) || candidate.path)
-    }];
-  });
-  if (agents.length === 1) return agents[0];
-  clearScreen();
-  printHeader({ env, platform });
-  print("");
-  print(col.bold("  Which agent do you want to run?"));
-  print("");
-  const items = agents.map((a) => `${a.displayName.padEnd(32)}  ${col.gray(a.path)}`);
-  const idx = await pickMenu(items, { allowBack: true });
-  if (idx === null || idx === -1) return null;
-  return agents[idx];
-}
-async function chooseCloudWorkspace({ env, platform, loadingTitle, pickerTitle } = {}) {
-  print("");
-  process.stdout.write(`  ${col.gray(loadingTitle || "Loading workspaces...")}
-`);
-  let wsResult;
-  try {
-    wsResult = await listCloudWorkspaces({
-      env,
-      platform,
-      onProgress: (msg) => {
-        process.stdout.write(`\r  ${col.gray(clip(msg, 60))}            `);
-      }
-    });
-    process.stdout.write("\r" + " ".repeat(70) + "\r");
-  } catch (error) {
-    process.stdout.write("\r" + " ".repeat(70) + "\r");
-    print(col.red(`
-  Couldn't connect: ${errMsg(error)}`));
-    print(col.gray("  Make sure you are signed in (choose Login / Switch from the menu)."));
-    await pressEnterToContinue({ grabActive: false });
-    return null;
-  }
-  if (!wsResult.ok) {
-    print(col.red(`
-  ${fig.cross} ${wsResult.error}`));
-    await pressEnterToContinue({ grabActive: false });
-    return null;
-  }
-  if (wsResult.workspaces.length === 0) return null;
-  if (wsResult.workspaces.length === 1) {
-    const ws2 = wsResult.workspaces[0];
-    return { id: ws2.id || "", label: workspaceLabel(ws2) };
-  }
-  clearScreen();
-  print("");
-  printHeader({ env, platform });
-  print("");
-  print(col.bold(`  ${pickerTitle || "Choose a workspace:"}`));
-  print("");
-  const items = wsResult.workspaces.map((ws2) => workspaceLabel(ws2));
-  const idx = await pickMenu(items, { allowBack: true });
-  if (idx === null || idx === -1) return null;
-  const ws = wsResult.workspaces[idx];
-  return { id: ws.id || "", label: workspaceLabel(ws) };
-}
 async function showCreate({ env, platform }) {
   clearScreen();
   printHeader({ env, platform });
@@ -3647,43 +3494,18 @@ async function showCreate({ env, platform }) {
   );
   return "home";
 }
-async function showRun({ env, platform }) {
-  const candidates = findAgentDirectoryCandidates();
-  const picked = await pickSingleAgentToRun({ env, platform, candidates });
-  if (!picked) return "home";
-  const workspace = await chooseCloudWorkspace({
-    env,
-    platform,
-    loadingTitle: "Getting ready to run this agent...",
-    pickerTitle: "Which project should own this run?"
-  });
-  if (!workspace) return "home";
-  const inputJson = await ask("Input JSON", "{}");
-  await withOutputMode(
-    `Running ${picked.displayName}`,
-    () => forwardToPythonVendian(buildLocalRunArgs({
-      agentPath: picked.path,
-      collectionId: workspace.id,
-      inputJson: inputJson || "{}"
-    }), { env, platform })
-  );
-  return "home";
-}
 async function showServe({ env, platform }) {
   const candidates = findAgentDirectoryCandidates();
   const picked = await pickAgentsToRun({ env, platform, candidates });
   if (!picked) return "home";
   const { agentsDir: agentsDir2 } = picked;
-  const workspace = await chooseCloudWorkspace({
+  return await runServeDashboard({
     env,
     platform,
-    loadingTitle: "Getting ready to run your agents...",
-    pickerTitle: "Which project do you want to run?"
+    agentsDir: agentsDir2
   });
-  if (!workspace) return "home";
-  return await runServeDashboard({ env, platform, agentsDir: agentsDir2, collectionId: workspace.id, wsLabel: workspace.label });
 }
-async function runServeDashboard({ env, platform, agentsDir: agentsDir2, collectionId: collectionId2, wsLabel = "" }) {
+async function runServeDashboard({ env, platform, agentsDir: agentsDir2 }) {
   let state = initialServeState();
   let child = null;
   let ctrlCArmed = false;
@@ -3703,7 +3525,7 @@ async function runServeDashboard({ env, platform, agentsDir: agentsDir2, collect
   print(col.gray("\u2550".repeat(W)));
   print(`  ${col.cyan(col.bold("\u2191 VENDIAN"))}  ${col.bold("Serving agents")}`);
   print(`  ${col.gray("Dir:")}       ${agentsDir2}`);
-  print(`  ${col.gray("Workspace:")} ${wsLabel || collectionId2 || "\u2014"}`);
+  print(`  ${col.gray("Backend:")}   ${envLabel(activeCloudAuthStatus({ env, platform }).apiUrl) || "active endpoint"}`);
   print(col.gray(hr(W)));
   print(col.gray("  S stop gracefully  |  ^c ^c exit"));
   print(col.gray(hr(W)));
@@ -3820,7 +3642,7 @@ async function runServeDashboard({ env, platform, agentsDir: agentsDir2, collect
     }
   }
   try {
-    logStore2 = createServeLogStore({ agentsDir: agentsDir2, collectionId: collectionId2, env, platform });
+    logStore2 = createServeLogStore({ agentsDir: agentsDir2, env, platform });
     const historicalLogs = logStore2.load();
     if (historicalLogs.length > 0) {
       const agentLogs = mergeAgentLogRecords(state.agentLogs, historicalLogs);
@@ -3828,7 +3650,6 @@ async function runServeDashboard({ env, platform, agentsDir: agentsDir2, collect
     }
     child = await spawnLocalServeEventStream({
       agentsDir: agentsDir2,
-      collectionId: collectionId2,
       env,
       platform,
       onProgress: (msg) => {
@@ -4020,9 +3841,6 @@ async function mainLoop({ env, platform }) {
       case "create":
         next = await showCreate({ env, platform });
         break;
-      case "run":
-        next = await showRun({ env, platform });
-        break;
       case "serve":
         next = await showServe({ env, platform });
         break;
@@ -4126,23 +3944,6 @@ function endpointErrorStatus(error) {
   const message = error && typeof error.message === "string" ? error.message : String(error || "Connection failed");
   return `${fig.cross} ${message}`;
 }
-function buildLocalRunArgs({
-  agentPath = ".",
-  collectionId: collectionId2 = "",
-  inputJson = "{}"
-} = {}) {
-  return [
-    "cloud",
-    "local",
-    "run",
-    "--collection-id",
-    collectionId2,
-    "--path",
-    agentPath || ".",
-    "--input-json",
-    inputJson || "{}"
-  ];
-}
 function stopSignalForAttempt(attempt = 0) {
   if (!Number.isFinite(attempt) || attempt <= 0) return "SIGINT";
   if (attempt === 1) return "SIGTERM";
@@ -4162,7 +3963,7 @@ function helpText() {
     "    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 init                  Write SDK agent docs into a folder",
     '    vendian create "My Agent"     Scaffold a new agent from templates',
     "    vendian dev                   Open the dev UI (alias for bare vendian)",
     "    vendian <command>             Run a managed Python SDK/cloud command",
@@ -4176,8 +3977,9 @@ function helpText() {
     "    vendian validate ./agents/my-agent --runtime",
     "    vendian models",
     "    vendian cloud local serve --agents-dir ./agents",
-    "    vendian cloud local push --collection-id ID --project-id PID --branch dev",
-    "    vendian cloud local push --branch feature/x --from dev",
+    "    vendian cloud suite status --path vendian-suite.yaml --remote",
+    "    vendian cloud suite push --path vendian-suite.yaml --wait",
+    "    vendian cloud suite deploy --path vendian-suite.yaml --environment staging",
     "    vendian doctor",
     "    vendian update",
     "",