@vendian/cli 0.0.42 → 0.0.44

package/README.md

@@ -46,7 +46,7 @@ Agent authoring commands are also forwarded to the managed Python SDK CLI.
 `vendian init` writes the current SDK-owned authoring docs into `.vendian-docs/`,
 and `vendian create` scaffolds agents from the SDK templates. Updating the
 managed runtime refreshes these docs and templates with the Python SDK. The CLI
-remembers workspaces initialized with `vendian init` and refreshes their
+remembers folders initialized with `vendian init` and refreshes their
 `.vendian-docs/` automatically after `vendian update` or a managed auto-update.
 
 ## Local Data

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,60 +1521,8 @@ 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
+var LEGACY_COLLECTION_RESOLVED_EVENT = ["work", "space_resolved"].join("");
 function initialServeState() {
   return {
     connected: false,
@@ -1616,15 +1576,15 @@ 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 === "collection_resolved" || event.type === LEGACY_COLLECTION_RESOLVED_EVENT) {
+    return { ...next, collectionId: stringValue(event.collectionId), activity: "Collection 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 +1604,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 +1619,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 +1674,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 +1693,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 +1733,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 +1748,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 +1757,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 +1768,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 +1785,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 +1807,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 +1863,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 +1878,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 +1895,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 +1906,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 +1927,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 +1969,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 +1992,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 +2015,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 +2025,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 +2044,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 +2081,29 @@ 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 "collection_resolved":
+    case LEGACY_COLLECTION_RESOLVED_EVENT:
+      return { ...base, message: `collection resolved id=${stringValue(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 +2126,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 +2134,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 +2153,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 +2161,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 +2220,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 +2252,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 +2280,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 +2305,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, " ");
@@ -2500,7 +2461,7 @@ function buildLocalServeEventStreamArgs({ agentsDir: agentsDir2 = "./agents", co
 }
 
 // src/version.js
-var CLI_VERSION = true ? "0.0.42" : process.env.npm_package_version || "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.44" : process.env.npm_package_version || "0.0.0-dev";
 
 // src/dev-server.js
 var __dirname = path8.dirname(fileURLToPath(import.meta.url));
@@ -2513,6 +2474,7 @@ var logStore = null;
 var agentsDir = "";
 var activeServeAgentsDir = "";
 var collectionId = "";
+var activeAuthLogin = null;
 async function startDevServer({
   port = 3859,
   agents = "",
@@ -2620,8 +2582,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);
       }
@@ -2784,10 +2744,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]) {
@@ -2828,13 +2784,32 @@ async function loginOrActivateBackend({ backend, env, setupFn, statusFn, activat
 }
 async function apiAuthLogin(req, res, body) {
   try {
-    const result = await loginOrActivateBackend({ backend: body.backend });
+    const result = await runSingleAuthLogin({ backend: body.backend });
     const status = result.ok ? 200 : 400;
     jsonResponse(res, result, status);
   } catch (err) {
     jsonResponse(res, { ok: false, error: err.message || "Login failed" }, 500);
   }
 }
+async function runSingleAuthLogin({ backend, loginFn } = {}) {
+  if (activeAuthLogin?.promise) {
+    if (activeAuthLogin.backend !== backend) {
+      return {
+        ok: false,
+        error: `A Vendian sign-in is already in progress for ${activeAuthLogin.backend}. Finish that browser flow or wait for it to close, then try ${backend} again.`
+      };
+    }
+    return activeAuthLogin.promise;
+  }
+  const executeLogin = loginFn || loginOrActivateBackend;
+  const promise = Promise.resolve().then(() => executeLogin({ backend })).finally(() => {
+    if (activeAuthLogin?.promise === promise) {
+      activeAuthLogin = null;
+    }
+  });
+  activeAuthLogin = { backend, promise };
+  return promise;
+}
 async function apiValidate(req, res, body) {
   const targetPath = body.path || agentsDir;
   const invocation = await preparePythonVendianInvocation(
@@ -2856,9 +2831,6 @@ 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 };
 }
 function devServerStateAfterServeStart(current = {}, target = {}) {
@@ -3144,6 +3116,59 @@ init_paths();
 init_setup();
 init_process();
 
+// src/collections.js
+init_process();
+async function listCloudCollections({
+  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 collections from Vendian");
+  const result = run2(invocation.command, invocation.args, { env: invocation.env, timeout: timeoutMs });
+  if (!result.ok) {
+    return {
+      ok: false,
+      collections: [],
+      error: (result.stderr || result.stdout || `collection list exited with code ${result.status}`).trim()
+    };
+  }
+  try {
+    return { ok: true, collections: normalizeCollectionList(JSON.parse(result.stdout)), error: "" };
+  } catch (error) {
+    const message = error && typeof error.message === "string" ? error.message : String(error);
+    return { ok: false, collections: [], error: `Could not parse collection list: ${message}` };
+  }
+}
+function normalizeCollectionList(payload) {
+  const data = payload && typeof payload === "object" && "data" in payload ? payload.data : payload;
+  const raw = Array.isArray(data) ? data : data && typeof data === "object" && Array.isArray(data.data) ? data.data : data && typeof data === "object" && Array.isArray(data.collections) ? data.collections : [];
+  return raw.filter((item) => item && typeof item === "object").map((item) => ({
+    id: stringValue2(item.id),
+    name: stringValue2(item.name || item.slug || item.id || "Unnamed collection"),
+    slug: stringValue2(item.slug)
+  })).filter((item) => item.id);
+}
+function collectionLabel(collection) {
+  const name = collection?.name || collection?.slug || collection?.id || "Unnamed collection";
+  const slug = collection?.slug && collection.slug !== name ? ` (${collection.slug})` : "";
+  return `${name}${slug}`;
+}
+function stringValue2(value) {
+  return value == null ? "" : String(value).trim();
+}
+
 // src/ui/figures.js
 var supportsUnicode = process.platform !== "win32" || Boolean(
   process.env.WT_SESSION || // Windows Terminal
@@ -3443,7 +3468,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" },
@@ -3567,13 +3592,13 @@ async function pickSingleAgentToRun({ env, platform, candidates }) {
   if (idx === null || idx === -1) return null;
   return agents[idx];
 }
-async function chooseCloudWorkspace({ env, platform, loadingTitle, pickerTitle } = {}) {
+async function chooseCloudCollection({ env, platform, loadingTitle, pickerTitle } = {}) {
   print("");
-  process.stdout.write(`  ${col.gray(loadingTitle || "Loading workspaces...")}
+  process.stdout.write(`  ${col.gray(loadingTitle || "Loading collections...")}
 `);
-  let wsResult;
+  let result;
   try {
-    wsResult = await listCloudWorkspaces({
+    result = await listCloudCollections({
       env,
       platform,
       onProgress: (msg) => {
@@ -3589,28 +3614,28 @@ async function chooseCloudWorkspace({ env, platform, loadingTitle, pickerTitle }
     await pressEnterToContinue({ grabActive: false });
     return null;
   }
-  if (!wsResult.ok) {
+  if (!result.ok) {
     print(col.red(`
-  ${fig.cross} ${wsResult.error}`));
+  ${fig.cross} ${result.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) };
+  if (result.collections.length === 0) return null;
+  if (result.collections.length === 1) {
+    const collection2 = result.collections[0];
+    return { id: collection2.id || "", label: collectionLabel(collection2) };
   }
   clearScreen();
   print("");
   printHeader({ env, platform });
   print("");
-  print(col.bold(`  ${pickerTitle || "Choose a workspace:"}`));
+  print(col.bold(`  ${pickerTitle || "Choose a collection:"}`));
   print("");
-  const items = wsResult.workspaces.map((ws2) => workspaceLabel(ws2));
+  const items = result.collections.map((collection2) => collectionLabel(collection2));
   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) };
+  const collection = result.collections[idx];
+  return { id: collection.id || "", label: collectionLabel(collection) };
 }
 async function showCreate({ env, platform }) {
   clearScreen();
@@ -3631,19 +3656,19 @@ async function showRun({ env, platform }) {
   const candidates = findAgentDirectoryCandidates();
   const picked = await pickSingleAgentToRun({ env, platform, candidates });
   if (!picked) return "home";
-  const workspace = await chooseCloudWorkspace({
+  const collection = await chooseCloudCollection({
     env,
     platform,
     loadingTitle: "Getting ready to run this agent...",
-    pickerTitle: "Which project should own this run?"
+    pickerTitle: "Which collection should own this run?"
   });
-  if (!workspace) return "home";
+  if (!collection) return "home";
   const inputJson = await ask("Input JSON", "{}");
   await withOutputMode(
     `Running ${picked.displayName}`,
     () => forwardToPythonVendian(buildLocalRunArgs({
       agentPath: picked.path,
-      collectionId: workspace.id,
+      collectionId: collection.id,
       inputJson: inputJson || "{}"
     }), { env, platform })
   );
@@ -3654,16 +3679,15 @@ async function showServe({ env, platform }) {
   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,
+    collectionId: "",
+    collectionLabel: "Admin Local Lab"
   });
-  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, collectionId: collectionId2, collectionLabel: collectionLabel2 = "" }) {
   let state = initialServeState();
   let child = null;
   let ctrlCArmed = false;
@@ -3683,7 +3707,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("Scope:")}     ${collectionLabel2 || collectionId2 || "Admin Local Lab"}`);
   print(col.gray(hr(W)));
   print(col.gray("  S stop gracefully  |  ^c ^c exit"));
   print(col.gray(hr(W)));
@@ -4142,7 +4166,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",

package/dev-ui/css/app.css

@@ -152,22 +152,10 @@ body { font-family: var(--font); background: var(--bg-page); color: var(--text);
 .serve-section-title { font-size: 11px; font-weight: 700; color: var(--text-dim); text-transform: uppercase; letter-spacing: 0.5px; }
 .serve-section-desc { font-size: 12.5px; color: var(--text-secondary); margin-top: 3px; }
 .serve-section-meta { font-size: 11.5px; color: var(--text-dim); white-space: nowrap; padding-top: 1px; }
-#workspace-picker { display: grid; grid-template-columns: repeat(auto-fill, minmax(240px, 1fr)); gap: 10px; margin-bottom: 6px; }
 .serve-select-bar { display: flex; align-items: center; gap: 9px; padding: 10px 14px; border-radius: 8px; background: var(--bg-card); border: 1px solid var(--border); box-shadow: var(--shadow); margin-bottom: 14px; font-size: 13px; font-weight: 600; cursor: pointer; user-select: none; }
 .serve-select-bar:hover { background: var(--bg-hover); }
 .serve-select-bar input { width: 16px; height: 16px; accent-color: var(--accent-solid); cursor: pointer; }
 .serve-select-bar .count { margin-left: auto; font-weight: 400; color: var(--text-dim); font-size: 12px; }
-.workspace-card { background: var(--bg-card); border: 1px solid var(--border); border-radius: var(--radius-lg); padding: 14px 16px; text-align: left; cursor: pointer; transition: all var(--transition); box-shadow: var(--shadow); font: inherit; color: inherit; }
-.workspace-card:hover { border-color: var(--border-hover); transform: translateY(-1px); box-shadow: var(--shadow-lg); }
-.workspace-card.selected { border-color: var(--accent); background: var(--accent-bg); }
-.workspace-card-title-row { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; }
-.workspace-card-title { font-size: 13.5px; font-weight: 650; color: var(--text); }
-.workspace-card-slug { font-size: 11px; color: var(--text-dim); margin-top: 2px; }
-.workspace-card-id { font-size: 11px; font-family: var(--mono); color: var(--text-dim); margin-top: 10px; overflow: hidden; text-overflow: ellipsis; }
-.workspace-card-badge { font-size: 10px; font-weight: 700; padding: 3px 8px; border-radius: 4px; border: 1px solid var(--border); color: var(--text-dim); background: var(--bg-elevated); white-space: nowrap; }
-.workspace-card.selected .workspace-card-badge { color: var(--accent); border-color: var(--accent-border); background: white; }
-.workspace-empty { padding: 14px 16px; border-radius: var(--radius); background: var(--bg-card); border: 1px dashed var(--border); color: var(--text-secondary); font-size: 12.5px; }
-.workspace-empty.workspace-error { color: var(--red); border-color: var(--red-border); background: var(--red-bg); }
 .serve-folder { margin-bottom: 20px; }
 .serve-folder-title { display: flex; align-items: center; gap: 6px; margin-bottom: 8px; font-size: 10.5px; font-weight: 700; color: var(--text-dim); text-transform: uppercase; letter-spacing: 0.5px; }
 .serve-folder-title svg { width: 12px; height: 12px; opacity: 0.5; }

package/dev-ui/index.html

@@ -23,7 +23,7 @@
 
 <div class="layout">
   <aside class="sidebar">
-    <div class="nav-label">Workspace</div>
+    <div class="nav-label">Agents</div>
     <div class="nav-item active" data-page="agents">
       <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="7" height="7" rx="2"/><rect x="14" y="3" width="7" height="7" rx="2"/><rect x="3" y="14" width="7" height="7" rx="2"/><rect x="14" y="14" width="7" height="7" rx="2"/></svg>
       <span>Agents</span>
@@ -95,18 +95,9 @@
 
       <div id="serve-picker-section">
         <div class="serve-section-head">
-          <div>
-            <div class="serve-section-title">Workspace</div>
-            <div class="serve-section-desc">Choose the Vendian workspace that should own this daemon and its local runs.</div>
-          </div>
-          <div class="serve-section-meta" id="workspace-summary">Loading workspaces…</div>
-        </div>
-        <div id="workspace-picker"></div>
-
-        <div class="serve-section-head" style="margin-top:20px">
           <div>
             <div class="serve-section-title">Agents</div>
-            <div class="serve-section-desc">Pick which local agents this serve session should expose.</div>
+            <div class="serve-section-desc">Pick which local agents this Local Lab session should expose.</div>
           </div>
         </div>
         <div class="serve-select-bar" id="serve-select-bar">

package/dev-ui/js/app.js

@@ -1,7 +1,7 @@
 import { state, api } from './state.js';
 import { renderAgents } from './agents.js';
 import { populateValidateGrid, runValidateAll, triggerValidateAgent } from './validate.js';
-import { populateServePicker, toggleAll, startServe, stopServe, setServing, clearLogs, loadWorkspaces } from './serve.js';
+import { populateServePicker, toggleAll, startServe, stopServe, setServing, clearLogs } from './serve.js';
 import { loadAuth } from './settings.js';
 
 // ─── Navigation ───
@@ -20,10 +20,6 @@ window.addEventListener('navigate', (e) => {
   if (page === 'validate' && path) triggerValidateAgent(path);
 });
 
-window.addEventListener('auth-changed', () => {
-  loadWorkspaces();
-});
-
 // ─── Load agents ───
 async function loadAgents() {
   try {
@@ -96,8 +92,6 @@ document.getElementById('serve-select-bar').addEventListener('click', (e) => {
 // ─── Init ───
 loadAgents();
 loadAuth();
-loadWorkspaces();
 checkStatus();
 setInterval(checkStatus, 4000);
 setInterval(loadAgents, 8000);
-setInterval(loadWorkspaces, 15000);

package/dev-ui/js/serve.js

@@ -1,80 +1,5 @@
 import { state, api, esc, groupByFolder, formatTime } from './state.js';
 
-export async function loadWorkspaces() {
-  state.workspacesLoading = true;
-  state.workspacesError = '';
-  renderWorkspacePicker();
-  try {
-    const result = await api('/workspaces');
-    state.workspaces = Array.isArray(result.workspaces) ? result.workspaces : [];
-    const hasSelected = state.workspaces.some((workspace) => workspace.id === state.selectedWorkspaceId);
-    if (!hasSelected) {
-      state.selectedWorkspaceId = state.workspaces[0]?.id || '';
-    }
-    if (!result.ok) {
-      state.workspacesError = result.error || 'Could not load workspaces.';
-    }
-  } catch (error) {
-    state.workspaces = [];
-    state.selectedWorkspaceId = '';
-    state.workspacesError = error?.message || 'Could not load workspaces.';
-  } finally {
-    state.workspacesLoading = false;
-    renderWorkspacePicker();
-  }
-}
-
-export function renderWorkspacePicker() {
-  const container = document.getElementById('workspace-picker');
-  const summary = document.getElementById('workspace-summary');
-  if (!container || !summary) return;
-
-  if (state.workspacesLoading) {
-    summary.textContent = 'Loading workspaces…';
-    container.innerHTML = '<div class="workspace-empty">Loading workspaces from Vendian…</div>';
-    return;
-  }
-
-  if (state.workspacesError) {
-    summary.textContent = 'Workspace required';
-    container.innerHTML = `<div class="workspace-empty workspace-error">${esc(state.workspacesError)}</div>`;
-    return;
-  }
-
-  if (!state.workspaces.length) {
-    summary.textContent = 'No workspace available';
-    container.innerHTML = '<div class="workspace-empty">Sign in to a Vendian environment to load workspaces.</div>';
-    return;
-  }
-
-  const selected = state.workspaces.find((workspace) => workspace.id === state.selectedWorkspaceId) || state.workspaces[0];
-  if (selected && state.selectedWorkspaceId !== selected.id) {
-    state.selectedWorkspaceId = selected.id || '';
-  }
-  summary.textContent = `${state.workspaces.length} workspace${state.workspaces.length === 1 ? '' : 's'}`;
-  container.innerHTML = state.workspaces.map((workspace) => {
-    const selectedClass = workspace.id === state.selectedWorkspaceId ? ' selected' : '';
-    const slug = workspace.slug && workspace.slug !== workspace.name ? `<div class="workspace-card-slug">${esc(workspace.slug)}</div>` : '';
-    return `<button type="button" class="workspace-card${selectedClass}" data-workspace-id="${esc(workspace.id)}">
-      <div class="workspace-card-title-row">
-        <div>
-          <div class="workspace-card-title">${esc(workspace.name || workspace.id)}</div>
-          ${slug}
-        </div>
-        <div class="workspace-card-badge">${workspace.id === state.selectedWorkspaceId ? 'Selected' : 'Choose'}</div>
-      </div>
-      <div class="workspace-card-id">${esc(workspace.id)}</div>
-    </button>`;
-  }).join('');
-
-  container.querySelectorAll('[data-workspace-id]').forEach((button) => {
-    button.addEventListener('click', () => {
-      state.selectedWorkspaceId = button.dataset.workspaceId || '';
-      renderWorkspacePicker();
-    });
-  });
-}
-
 // ─── Picker ───
 let userSelections = null; // null = all selected (default), Set = explicit selections
 
@@ -160,9 +85,8 @@ export function getSelectedPaths() {
 // ─── Controls ───
 export async function startServe() {
   const selected = getSelectedPaths();
-  if (!state.selectedWorkspaceId) { alert('Choose a workspace before starting local serve.'); return; }
   if (!selected.length) { alert('Select at least one agent.'); return; }
-  const body = { collectionId: state.selectedWorkspaceId };
+  const body = {};
   if (selected.length < state.agents.length) {
     body.agentsDir = commonParent(selected);
   }

package/dev-ui/js/state.js

@@ -2,10 +2,6 @@
 export const state = {
   agents: [],
   authData: {},
-  workspaces: [],
-  selectedWorkspaceId: '',
-  workspacesLoading: false,
-  workspacesError: '',
   logOffset: 0,
   pollTimer: null,
   isServing: false,

package/package.json

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