@vendian/cli 0.0.33 → 0.0.35

package/cli-wrapper.mjs

@@ -2,152 +2,498 @@
 import { createRequire as __vendianCreateRequire } from 'node:module';
 const require = __vendianCreateRequire(import.meta.url);
 
-
-// src/doctor.js
-import fs4 from "node:fs";
-
-// src/config.js
-import fs from "node:fs";
-import path2 from "node:path";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/constants.js
-var DEFAULT_GITLAB_HOST = "gitlab.com";
-var DEFAULT_SDK_PUBLIC_PROJECT_ID = "77150592";
-var DEFAULT_SDK_RUNTIME_PROJECT_ID = "79410876";
-var PUBLIC_PACKAGE = "vendian-agents[full]";
-var RUNTIME_PACKAGE = "vendian-agents-runtime";
-var CONFIG_VERSION = 1;
-var BACKEND_TARGETS = {
-  local: "http://localhost:3000",
-  localhost: "http://localhost:3000",
-  dev: "https://api.dev.vendian.ai",
-  staging: "https://api.staging.vendian.ai",
-  prod: "https://api.vendian.ai",
-  production: "https://api.vendian.ai"
-};
+var DEFAULT_GITLAB_HOST, DEFAULT_SDK_PUBLIC_PROJECT_ID, DEFAULT_SDK_RUNTIME_PROJECT_ID, PUBLIC_PACKAGE, RUNTIME_PACKAGE, CONFIG_VERSION, BACKEND_TARGETS;
+var init_constants = __esm({
+  "src/constants.js"() {
+    DEFAULT_GITLAB_HOST = "gitlab.com";
+    DEFAULT_SDK_PUBLIC_PROJECT_ID = "77150592";
+    DEFAULT_SDK_RUNTIME_PROJECT_ID = "79410876";
+    PUBLIC_PACKAGE = "vendian-agents[full]";
+    RUNTIME_PACKAGE = "vendian-agents-runtime";
+    CONFIG_VERSION = 1;
+    BACKEND_TARGETS = {
+      local: "http://localhost:3000",
+      localhost: "http://localhost:3000",
+      dev: "https://api.dev.vendian.ai",
+      staging: "https://api.staging.vendian.ai",
+      prod: "https://api.vendian.ai",
+      production: "https://api.vendian.ai"
+    };
+  }
+});
 
-// src/paths.js
-import os from "node:os";
-import path from "node:path";
-function pathApi(platform) {
-  return platform === "win32" ? path.win32 : path.posix;
-}
-function homeDir(env, platform) {
-  if (platform === "win32") {
-    return env.USERPROFILE || os.homedir();
+// src/auth.js
+var auth_exports = {};
+__export(auth_exports, {
+  activateCloudProfile: () => activateCloudProfile,
+  activeCloudAuthStatus: () => activeCloudAuthStatus,
+  buildLinuxOpenCommand: () => buildLinuxOpenCommand,
+  buildMacOpenCommand: () => buildMacOpenCommand,
+  buildWindowsOpenCommand: () => buildWindowsOpenCommand,
+  cloudAuthStatus: () => cloudAuthStatus,
+  cloudConfigPath: () => cloudConfigPath,
+  fetchPackageCredentials: () => fetchPackageCredentials,
+  loadCloudConfig: () => loadCloudConfig,
+  loginWithVendianOAuth: () => loginWithVendianOAuth,
+  resolveApiUrl: () => resolveApiUrl,
+  saveCloudToken: () => saveCloudToken
+});
+import crypto from "node:crypto";
+import http from "node:http";
+import fs6 from "node:fs";
+import path5 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+function resolveApiUrl({ backend, apiUrl, env = process.env } = {}) {
+  if (apiUrl) {
+    return apiUrl.replace(/\/$/, "");
   }
-  return env.HOME || os.homedir();
-}
-function vendianHome(env = process.env, platform = process.platform) {
-  if (env.VENDIAN_CLI_HOME) {
-    return pathApi(platform).resolve(env.VENDIAN_CLI_HOME);
+  if (env.VENDIAN_API_URL) {
+    return env.VENDIAN_API_URL.replace(/\/$/, "");
   }
-  if (platform === "win32") {
-    const root = env.LOCALAPPDATA || path.win32.join(homeDir(env, platform), "AppData", "Local");
-    return path.win32.join(root, "Vendian", "cli");
+  const target = backend || "prod";
+  const resolved = BACKEND_TARGETS[target];
+  if (!resolved) {
+    throw new Error(`Unknown Vendian backend '${target}'. Use local, dev, staging, prod, or --api-url.`);
   }
-  return path.posix.join(homeDir(env, platform), ".vendian", "cli");
+  return resolved;
 }
-function configPath(env = process.env, platform = process.platform) {
-  if (env.VENDIAN_CLI_CONFIG) {
-    return pathApi(platform).resolve(env.VENDIAN_CLI_CONFIG);
+async function loginWithVendianOAuth({ backend, apiUrl, noBrowser = false, env = process.env } = {}) {
+  const resolvedApiUrl = resolveApiUrl({ backend, apiUrl, env });
+  const callback = await createCallbackServer(env);
+  try {
+    const config = await getOAuthConfig(resolvedApiUrl, callback.redirectUri);
+    const codeVerifier = crypto.randomBytes(48).toString("base64url");
+    const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
+    const state = crypto.randomBytes(18).toString("base64url");
+    const authorizationUrl = authorizationUrlFor(config, { state, codeChallenge });
+    if (noBrowser) {
+      console.error(`Open this URL to authenticate the CLI: ${authorizationUrl}`);
+    } else {
+      openBrowser(authorizationUrl);
+    }
+    const callbackResult = await callback.wait();
+    if (callbackResult.state !== state) {
+      throw new Error("OAuth state mismatch");
+    }
+    const clerkToken = await exchangeCodeForClerkToken(config, callbackResult.code, codeVerifier, callback.redirectUri);
+    const exchange = await postJson(`${resolvedApiUrl}/api/v1/cli/auth/oauth/exchange`, {
+      clerkToken
+    });
+    return { apiUrl: resolvedApiUrl, ...exchange };
+  } finally {
+    await callback.close();
   }
-  return pathApi(platform).join(vendianHome(env, platform), "config.json");
 }
-function managedVenvPath(env = process.env, platform = process.platform) {
-  if (env.VENDIAN_CLI_VENV) {
-    return pathApi(platform).resolve(env.VENDIAN_CLI_VENV);
+async function fetchPackageCredentials({ apiUrl, accessToken }) {
+  if (!apiUrl || !accessToken) {
+    return void 0;
   }
-  return pathApi(platform).join(vendianHome(env, platform), ".venv");
-}
-function venvPython(venvPath, platform = process.platform) {
-  return platform === "win32" ? path.win32.join(venvPath, "Scripts", "python.exe") : path.posix.join(venvPath, "bin", "python");
-}
-function venvVendian(venvPath, platform = process.platform) {
-  return platform === "win32" ? path.win32.join(venvPath, "Scripts", "vendian.exe") : path.posix.join(venvPath, "bin", "vendian");
+  const payload = await getJson(`${String(apiUrl).replace(/\/$/, "")}/api/v1/cli/package-credentials`, {
+    Authorization: `Bearer ${accessToken}`
+  });
+  return payload.packageCredentials;
 }
-
-// src/config.js
-function loadConfig(env = process.env, platform = process.platform) {
-  const file = configPath(env, platform);
+function loadCloudConfig(env = process.env, platform = process.platform) {
+  const file = cloudConfigPath(env, platform);
   try {
-    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-    return typeof parsed === "object" && parsed !== null ? parsed : {};
-  } catch (error) {
-    if (error && error.code === "ENOENT") {
-      return {};
-    }
+    const parsed = JSON.parse(fs6.readFileSync(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
     return {};
   }
 }
-function saveConfig(config, env = process.env, platform = process.platform) {
-  const file = configPath(env, platform);
-  fs.mkdirSync(path2.dirname(file), { recursive: true });
-  const next = { version: CONFIG_VERSION, ...config };
-  fs.writeFileSync(file, `${JSON.stringify(next, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-  try {
-    fs.chmodSync(file, 384);
-  } catch {
-  }
-  return file;
+function cloudAuthStatus({ backend, apiUrl, env = process.env, platform = process.platform } = {}) {
+  const targetApiUrl = resolveApiUrl({ backend, apiUrl, env });
+  const config = loadCloudConfig(env, platform);
+  const profiles = config.profiles && typeof config.profiles === "object" ? config.profiles : {};
+  const profile = profiles[targetApiUrl];
+  return {
+    apiUrl: targetApiUrl,
+    activeApiUrl: typeof config.active_api_url === "string" ? config.active_api_url : void 0,
+    profile: profile && typeof profile === "object" ? profile : void 0,
+    authenticated: Boolean(profile?.access_token),
+    email: typeof profile?.email === "string" ? profile.email : void 0,
+    expiresAt: typeof profile?.expires_at === "string" ? profile.expires_at : void 0,
+    profiles
+  };
 }
-
-// src/install.js
-import fs3 from "node:fs";
-import path3 from "node:path";
-
-// src/process.js
-import { spawn, spawnSync } from "node:child_process";
-function commandExists(command) {
-  const result = spawnSync(command, ["--version"], { stdio: "ignore", shell: false });
-  return result.status === 0;
+function activeCloudAuthStatus({ env = process.env, platform = process.platform } = {}) {
+  const config = loadCloudConfig(env, platform);
+  const profiles = config.profiles && typeof config.profiles === "object" ? config.profiles : {};
+  const apiUrl = typeof config.active_api_url === "string" ? config.active_api_url : void 0;
+  const profile = apiUrl ? profiles[apiUrl] : void 0;
+  return {
+    apiUrl,
+    activeApiUrl: apiUrl,
+    profile: profile && typeof profile === "object" ? profile : void 0,
+    authenticated: Boolean(profile?.access_token),
+    email: typeof profile?.email === "string" ? profile.email : void 0,
+    expiresAt: typeof profile?.expires_at === "string" ? profile.expires_at : void 0,
+    profiles
+  };
 }
-function runCapture(command, args, options = {}) {
-  const result = spawnSync(command, args, {
-    encoding: "utf8",
-    shell: false,
-    ...options
-  });
-  const errorMessage = result.error && typeof result.error.message === "string" ? result.error.message : "";
+function activateCloudProfile({ backend, apiUrl, env = process.env, platform = process.platform } = {}) {
+  const targetApiUrl = resolveApiUrl({ backend, apiUrl, env });
+  const config = loadCloudConfig(env, platform);
+  const profiles = config.profiles && typeof config.profiles === "object" ? config.profiles : {};
+  const profile = profiles[targetApiUrl];
+  if (!profile || typeof profile !== "object" || !profile.access_token) {
+    return {
+      apiUrl: targetApiUrl,
+      activeApiUrl: typeof config.active_api_url === "string" ? config.active_api_url : void 0,
+      authenticated: false,
+      activated: false,
+      profiles
+    };
+  }
+  const next = {
+    ...config,
+    version: config.version || 2,
+    profiles,
+    active_api_url: targetApiUrl
+  };
+  writeCloudConfig(next, { env, platform });
   return {
-    ok: !result.error && result.status === 0,
-    status: result.status ?? 1,
-    stdout: result.stdout || "",
-    stderr: result.stderr || errorMessage
+    apiUrl: targetApiUrl,
+    activeApiUrl: targetApiUrl,
+    profile,
+    authenticated: true,
+    activated: true,
+    email: typeof profile.email === "string" ? profile.email : void 0,
+    expiresAt: typeof profile.expires_at === "string" ? profile.expires_at : void 0,
+    profiles
   };
 }
-function runInherit(command, args, options = {}) {
-  const result = spawnSync(command, args, {
-    stdio: "inherit",
-    shell: false,
-    ...options
+async function getOAuthConfig(apiUrl, redirectUri) {
+  const url = new URL(`${apiUrl}/api/v1/cli/auth/oauth/config`);
+  url.searchParams.set("redirectUri", redirectUri);
+  return getJson(url);
+}
+function authorizationUrlFor(config, { state, codeChallenge }) {
+  const url = new URL(String(config.authorizationUrl));
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", String(config.clientId));
+  url.searchParams.set("redirect_uri", String(config.redirectUri));
+  url.searchParams.set("scope", String(config.scopes || "email profile"));
+  url.searchParams.set("state", state);
+  url.searchParams.set("code_challenge", codeChallenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  return url.toString();
+}
+async function exchangeCodeForClerkToken(config, code, codeVerifier, redirectUri) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: String(config.clientId),
+    code,
+    redirect_uri: redirectUri,
+    code_verifier: codeVerifier
   });
-  if (result.error) {
-    throw result.error;
+  const payload = await postForm(String(config.tokenUrl), body);
+  const token = payload.access_token || payload.id_token;
+  if (!token) {
+    throw new Error("OAuth token exchange did not return a Clerk token");
   }
-  return result.status ?? 1;
+  return String(token);
 }
-function spawnForward(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: "inherit",
-      shell: false,
-      ...options
-    });
-    child.on("error", reject);
-    child.on("exit", (code, signal) => {
-      if (signal) {
-        reject(new Error(`command terminated by ${signal}`));
-        return;
-      }
-      resolve(code ?? 1);
-    });
-  });
+async function getJson(url, headers = {}) {
+  const response = await fetch(url, { headers: { Accept: "application/json", ...headers } });
+  return decodeResponse(response);
 }
-
-// src/python.js
-import fs2 from "node:fs";
+async function postJson(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  return decodeResponse(response);
+}
+async function postForm(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  return decodeResponse(response);
+}
+async function decodeResponse(response) {
+  const text = await response.text();
+  let payload = {};
+  if (text) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = { error: text };
+    }
+  }
+  if (!response.ok) {
+    throw new Error(payload.message || payload.error || `HTTP ${response.status}`);
+  }
+  return payload;
+}
+async function createCallbackServer(env) {
+  const port = Number(env.VENDIAN_CLI_OAUTH_REDIRECT_PORT || DEFAULT_OAUTH_REDIRECT_PORT);
+  let server;
+  let settled = false;
+  let timeout;
+  const waitPromise = new Promise((resolve, reject) => {
+    timeout = setTimeout(() => {
+      settled = true;
+      reject(new Error("OAuth login timed out before callback completed"));
+    }, 3e5);
+    server = http.createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      const body = code ? "Vendian CLI authentication complete. You can close this window." : "Vendian CLI authentication failed. Return to the terminal.";
+      res.writeHead(code ? 200 : 400, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Content-Length": Buffer.byteLength(body)
+      });
+      res.end(body);
+      clearTimeout(timeout);
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (error) {
+        reject(new Error(`OAuth login failed: ${error}`));
+        return;
+      }
+      if (!code) {
+        reject(new Error("OAuth callback did not include an authorization code"));
+        return;
+      }
+      resolve({ code, state });
+    });
+    server.on("error", reject);
+    server.listen(port, "127.0.0.1");
+  });
+  await new Promise((resolve, reject) => {
+    server.once("listening", resolve);
+    server.once("error", reject);
+  });
+  return {
+    redirectUri: `http://127.0.0.1:${server.address().port}/callback`,
+    wait: () => waitPromise,
+    close: () => new Promise((resolve) => server.close(resolve))
+  };
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  if (platform === "win32") {
+    spawnSync3(...buildWindowsOpenCommand(url), { stdio: "ignore", shell: false });
+    return;
+  }
+  if (platform === "darwin") {
+    spawnSync3(...buildMacOpenCommand(url), { stdio: "ignore", shell: false });
+    return;
+  }
+  spawnSync3(...buildLinuxOpenCommand(url), { stdio: "ignore", shell: false });
+}
+function buildWindowsOpenCommand(url) {
+  return ["rundll32.exe", ["url.dll,FileProtocolHandler", String(url)]];
+}
+function buildMacOpenCommand(url) {
+  return ["open", [String(url)]];
+}
+function buildLinuxOpenCommand(url) {
+  return ["xdg-open", [String(url)]];
+}
+function cloudConfigPath(env = process.env, platform = process.platform) {
+  if (env.VENDIAN_CLOUD_CONFIG) {
+    return path5.resolve(env.VENDIAN_CLOUD_CONFIG);
+  }
+  if (platform === "win32") {
+    const root2 = env.APPDATA || path5.join(process.env.USERPROFILE || "", "AppData", "Roaming");
+    return path5.win32.join(root2, "Vendian", "cloud-auth.json");
+  }
+  const root = env.XDG_CONFIG_HOME || path5.join(process.env.HOME || "", ".config");
+  return path5.posix.join(root, "vendian", "cloud-auth.json");
+}
+function saveCloudToken(token, { env = process.env, platform = process.platform } = {}) {
+  const tokenApiUrl = String(token.apiUrl || "").replace(/\/$/, "");
+  let raw = { version: 2, profiles: {}, active_api_url: token.apiUrl };
+  try {
+    const existing = loadCloudConfig(env, platform);
+    if (existing && typeof existing === "object" && existing.profiles && typeof existing.profiles === "object") {
+      raw.profiles = existing.profiles;
+    }
+  } catch {
+  }
+  raw.active_api_url = tokenApiUrl;
+  raw.profiles[tokenApiUrl] = {
+    api_url: tokenApiUrl,
+    access_token: token.accessToken,
+    user_id: token.userId,
+    email: token.email,
+    expires_at: token.expiresAt,
+    scopes: token.scopes,
+    tooling_eligible: token.toolingEligible
+  };
+  return writeCloudConfig(raw, { env, platform });
+}
+function writeCloudConfig(raw, { env = process.env, platform = process.platform } = {}) {
+  const file = cloudConfigPath(env, platform);
+  fs6.mkdirSync(path5.dirname(file), { recursive: true });
+  fs6.writeFileSync(file, `${JSON.stringify(raw, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  try {
+    fs6.chmodSync(file, 384);
+  } catch {
+  }
+  return file;
+}
+var DEFAULT_OAUTH_REDIRECT_PORT;
+var init_auth = __esm({
+  "src/auth.js"() {
+    init_constants();
+    DEFAULT_OAUTH_REDIRECT_PORT = 8765;
+  }
+});
+
+// src/doctor.js
+import fs4 from "node:fs";
+
+// src/config.js
+init_constants();
+import fs from "node:fs";
+import path2 from "node:path";
+
+// src/paths.js
+import os from "node:os";
+import path from "node:path";
+function pathApi(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function homeDir(env, platform) {
+  if (platform === "win32") {
+    return env.USERPROFILE || os.homedir();
+  }
+  return env.HOME || os.homedir();
+}
+function vendianHome(env = process.env, platform = process.platform) {
+  if (env.VENDIAN_CLI_HOME) {
+    return pathApi(platform).resolve(env.VENDIAN_CLI_HOME);
+  }
+  if (platform === "win32") {
+    const root = env.LOCALAPPDATA || path.win32.join(homeDir(env, platform), "AppData", "Local");
+    return path.win32.join(root, "Vendian", "cli");
+  }
+  return path.posix.join(homeDir(env, platform), ".vendian", "cli");
+}
+function configPath(env = process.env, platform = process.platform) {
+  if (env.VENDIAN_CLI_CONFIG) {
+    return pathApi(platform).resolve(env.VENDIAN_CLI_CONFIG);
+  }
+  return pathApi(platform).join(vendianHome(env, platform), "config.json");
+}
+function managedVenvPath(env = process.env, platform = process.platform) {
+  if (env.VENDIAN_CLI_VENV) {
+    return pathApi(platform).resolve(env.VENDIAN_CLI_VENV);
+  }
+  return pathApi(platform).join(vendianHome(env, platform), ".venv");
+}
+function venvPython(venvPath, platform = process.platform) {
+  return platform === "win32" ? path.win32.join(venvPath, "Scripts", "python.exe") : path.posix.join(venvPath, "bin", "python");
+}
+function venvVendian(venvPath, platform = process.platform) {
+  return platform === "win32" ? path.win32.join(venvPath, "Scripts", "vendian.exe") : path.posix.join(venvPath, "bin", "vendian");
+}
+
+// src/config.js
+function loadConfig(env = process.env, platform = process.platform) {
+  const file = configPath(env, platform);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return {};
+    }
+    return {};
+  }
+}
+function saveConfig(config, env = process.env, platform = process.platform) {
+  const file = configPath(env, platform);
+  fs.mkdirSync(path2.dirname(file), { recursive: true });
+  const next = { version: CONFIG_VERSION, ...config };
+  fs.writeFileSync(file, `${JSON.stringify(next, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  try {
+    fs.chmodSync(file, 384);
+  } catch {
+  }
+  return file;
+}
+
+// src/install.js
+init_constants();
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// src/process.js
+import { spawn, spawnSync } from "node:child_process";
+function commandExists(command) {
+  const result = spawnSync(command, ["--version"], { stdio: "ignore", shell: false });
+  return result.status === 0;
+}
+function runCapture(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    shell: false,
+    ...options
+  });
+  const errorMessage = result.error && typeof result.error.message === "string" ? result.error.message : "";
+  return {
+    ok: !result.error && result.status === 0,
+    status: result.status ?? 1,
+    stdout: result.stdout || "",
+    stderr: result.stderr || errorMessage
+  };
+}
+function runInherit(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: "inherit",
+    shell: false,
+    ...options
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  return result.status ?? 1;
+}
+function spawnForward(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      shell: false,
+      ...options
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`command terminated by ${signal}`));
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}
+
+// src/python.js
+import fs2 from "node:fs";
 function findPython(platform = process.platform) {
   const candidates = platform === "win32" ? [
     { command: "py", args: ["-3.11"] },
@@ -408,421 +754,348 @@ function doctor({ env = process.env, platform = process.platform } = {}) {
   const vendianPath = venvVendian(venvPath, platform);
   const registry = registryConfig(config, env, platform);
   console.log("Vendian doctor");
-  console.log(`Home: ${venvPath}`);
-  console.log(`System Python 3.11+: ${findPython(platform) ? "yes" : "no"}`);
-  console.log(`uv: ${hasUv() ? "yes" : "no, will use pip fallback"}`);
-  console.log(`Managed Python: ${fs4.existsSync(pythonPath) ? pythonVersion(pythonPath) || "present" : "missing"}`);
-  console.log(`Vendian executable: ${fs4.existsSync(vendianPath) ? vendianPath : "missing"}`);
-  console.log(`Vendian imports: ${fs4.existsSync(pythonPath) && verifyVendianImports(pythonPath) ? "ok" : "missing"}`);
-  console.log(`Package access: ${registry.token ? `configured (${registry.tokenSource})` : "missing"}`);
-}
-
-// src/forward.js
-import fs8 from "node:fs";
-
-// src/docs.js
-import fs5 from "node:fs";
-import path4 from "node:path";
-var DOC_WORKSPACES_KEY = "agentDocWorkspaces";
-function pathApi2(platform) {
-  return platform === "win32" ? path4.win32 : path4.posix;
-}
-function commandWritesAgentDocs(args = []) {
-  return args[0] === "init";
-}
-function initOutputDir(args = []) {
-  for (let index = 1; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--output-dir" || arg === "-o") {
-      return args[index + 1] || ".";
-    }
-    if (arg.startsWith("--output-dir=")) {
-      return arg.slice("--output-dir=".length) || ".";
-    }
-  }
-  return ".";
-}
-function resolveWorkspacePath(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, {
-  env = process.env,
-  platform = process.platform,
-  cwd = process.cwd(),
-  now = /* @__PURE__ */ new Date()
-} = {}) {
-  const workspacePath = resolveWorkspacePath(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 next = {
-    ...config,
-    [DOC_WORKSPACES_KEY]: workspaces,
-    lastAgentDocsInitAt: now.toISOString()
-  };
-  saveConfig(next, env, platform);
-  return next;
-}
-function recordForwardedDocsCommand(args, code, options = {}) {
-  if (code !== 0 || !commandWritesAgentDocs(args)) {
-    return false;
-  }
-  recordAgentDocsWorkspace(initOutputDir(args), options);
-  return true;
+  console.log(`Home: ${venvPath}`);
+  console.log(`System Python 3.11+: ${findPython(platform) ? "yes" : "no"}`);
+  console.log(`uv: ${hasUv() ? "yes" : "no, will use pip fallback"}`);
+  console.log(`Managed Python: ${fs4.existsSync(pythonPath) ? pythonVersion(pythonPath) || "present" : "missing"}`);
+  console.log(`Vendian executable: ${fs4.existsSync(vendianPath) ? vendianPath : "missing"}`);
+  console.log(`Vendian imports: ${fs4.existsSync(pythonPath) && verifyVendianImports(pythonPath) ? "ok" : "missing"}`);
+  console.log(`Package access: ${registry.token ? `configured (${registry.tokenSource})` : "missing"}`);
 }
-function refreshAgentDocsWorkspaces({
-  config,
-  venvPath,
-  env = process.env,
-  platform = process.platform,
-  run: run2 = runInherit,
-  now = /* @__PURE__ */ new Date()
+
+// src/dev-server.js
+import http2 from "node:http";
+import fs11 from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn as spawn3 } from "node:child_process";
+
+// src/agent-discovery.js
+import fs5 from "node:fs";
+import os2 from "node:os";
+import path4 from "node:path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".agents",
+  ".git",
+  ".hg",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".svn",
+  ".venv",
+  "__pycache__",
+  "build",
+  "dist",
+  "node_modules",
+  "venv"
+]);
+var MANIFEST_NAMES = /* @__PURE__ */ new Set(["manifest.yaml", "manifest.yml"]);
+function findAgentDirectoryCandidates({
+  cwd = process.cwd(),
+  home = os2.homedir(),
+  maxDepth = 6,
+  maxDirs = 1e3,
+  limit = 12
 } = {}) {
-  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) {
-    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 (!fs5.existsSync(workspace)) {
-      continue;
+  const start = path4.resolve(cwd);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  function addCandidate(candidatePath) {
+    const resolved = safeResolve(candidatePath);
+    if (!resolved || seen.has(resolved)) {
+      return;
     }
-    const status = run2(vendianPath, ["init", "--output-dir", workspace, "--yes"]);
-    if (status === 0) {
-      refreshed += 1;
-    } else {
-      failed += 1;
-      console.error(`[vendian] Could not refresh SDK docs in ${workspace}`);
+    const count = countAgentManifests(resolved, { maxDepth, maxDirs, limit: 100 });
+    if (count < 1) {
+      return;
     }
+    seen.add(resolved);
+    candidates.push({
+      path: displayPath(resolved, start),
+      absolutePath: resolved,
+      agentCount: count
+    });
   }
-  const next = {
-    ...currentConfig,
-    [DOC_WORKSPACES_KEY]: workspaces,
-    lastAgentDocsRefreshAt: now.toISOString()
-  };
-  saveConfig(next, env, platform);
-  return { config: next, refreshed, failed };
-}
-
-// src/setup.js
-import fs7 from "node:fs";
-
-// src/auth.js
-import crypto from "node:crypto";
-import http from "node:http";
-import fs6 from "node:fs";
-import path5 from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
-var DEFAULT_OAUTH_REDIRECT_PORT = 8765;
-function resolveApiUrl({ backend, apiUrl, env = process.env } = {}) {
-  if (apiUrl) {
-    return apiUrl.replace(/\/$/, "");
+  addCandidate(path4.join(start, "agents"));
+  if (hasDirectManifest(start)) {
+    addCandidate(start);
   }
-  if (env.VENDIAN_API_URL) {
-    return env.VENDIAN_API_URL.replace(/\/$/, "");
+  for (const parent of parentDirs(start, 3)) {
+    addCandidate(path4.join(parent, "agents"));
   }
-  const target = backend || "prod";
-  const resolved = BACKEND_TARGETS[target];
-  if (!resolved) {
-    throw new Error(`Unknown Vendian backend '${target}'. Use local, dev, staging, prod, or --api-url.`);
+  const roots = uniqueExistingDirs([
+    start,
+    ...commonSearchRoots(home)
+  ]);
+  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));
+      if (candidates.length >= limit) {
+        return candidates.slice(0, limit);
+      }
+    }
   }
-  return resolved;
+  return candidates.slice(0, limit);
 }
-async function loginWithVendianOAuth({ backend, apiUrl, noBrowser = false, env = process.env } = {}) {
-  const resolvedApiUrl = resolveApiUrl({ backend, apiUrl, env });
-  const callback = await createCallbackServer(env);
-  try {
-    const config = await getOAuthConfig(resolvedApiUrl, callback.redirectUri);
-    const codeVerifier = crypto.randomBytes(48).toString("base64url");
-    const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
-    const state = crypto.randomBytes(18).toString("base64url");
-    const authorizationUrl = authorizationUrlFor(config, { state, codeChallenge });
-    if (noBrowser) {
-      console.error(`Open this URL to authenticate the CLI: ${authorizationUrl}`);
-    } else {
-      openBrowser(authorizationUrl);
-    }
-    const callbackResult = await callback.wait();
-    if (callbackResult.state !== state) {
-      throw new Error("OAuth state mismatch");
+function findAgentFolders(root, {
+  cwd = process.cwd(),
+  maxDepth = 6,
+  maxDirs = 1e3,
+  limit = 100
+} = {}) {
+  const start = path4.resolve(cwd);
+  const resolvedRoot = safeResolve(root || ".");
+  if (!resolvedRoot) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const folders = [];
+  for (const manifest of findManifestFiles(resolvedRoot, { maxDepth, maxDirs, limit })) {
+    const folder = path4.dirname(manifest);
+    const resolved = safeResolve(folder);
+    if (!resolved || seen.has(resolved)) {
+      continue;
     }
-    const clerkToken = await exchangeCodeForClerkToken(config, callbackResult.code, codeVerifier, callback.redirectUri);
-    const exchange = await postJson(`${resolvedApiUrl}/api/v1/cli/auth/oauth/exchange`, {
-      clerkToken
+    seen.add(resolved);
+    folders.push({
+      path: displayPath(resolved, start),
+      absolutePath: resolved,
+      name: path4.basename(resolved) || displayPath(resolved, start)
     });
-    return { apiUrl: resolvedApiUrl, ...exchange };
-  } finally {
-    await callback.close();
-  }
-}
-async function fetchPackageCredentials({ apiUrl, accessToken }) {
-  if (!apiUrl || !accessToken) {
-    return void 0;
   }
-  const payload = await getJson(`${String(apiUrl).replace(/\/$/, "")}/api/v1/cli/package-credentials`, {
-    Authorization: `Bearer ${accessToken}`
-  });
-  return payload.packageCredentials;
+  return folders.sort((a, b) => a.path.localeCompare(b.path)).slice(0, limit);
 }
-function loadCloudConfig(env = process.env, platform = process.platform) {
-  const file = cloudConfigPath(env, platform);
-  try {
-    const parsed = JSON.parse(fs6.readFileSync(file, "utf8"));
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
+function countAgentManifests(root, { maxDepth = 6, maxDirs = 1e3, limit = 100 } = {}) {
+  let count = 0;
+  for (const _manifest of findManifestFiles(root, { maxDepth, maxDirs, limit })) {
+    count += 1;
+    if (count >= limit) {
+      return count;
+    }
   }
+  return count;
 }
-function cloudAuthStatus({ backend, apiUrl, env = process.env, platform = process.platform } = {}) {
-  const targetApiUrl = resolveApiUrl({ backend, apiUrl, env });
-  const config = loadCloudConfig(env, platform);
-  const profiles = config.profiles && typeof config.profiles === "object" ? config.profiles : {};
-  const profile = profiles[targetApiUrl];
-  return {
-    apiUrl: targetApiUrl,
-    activeApiUrl: typeof config.active_api_url === "string" ? config.active_api_url : void 0,
-    profile: profile && typeof profile === "object" ? profile : void 0,
-    authenticated: Boolean(profile?.access_token),
-    email: typeof profile?.email === "string" ? profile.email : void 0,
-    expiresAt: typeof profile?.expires_at === "string" ? profile.expires_at : void 0,
-    profiles
-  };
-}
-function activeCloudAuthStatus({ env = process.env, platform = process.platform } = {}) {
-  const config = loadCloudConfig(env, platform);
-  const profiles = config.profiles && typeof config.profiles === "object" ? config.profiles : {};
-  const apiUrl = typeof config.active_api_url === "string" ? config.active_api_url : void 0;
-  const profile = apiUrl ? profiles[apiUrl] : void 0;
-  return {
-    apiUrl,
-    activeApiUrl: apiUrl,
-    profile: profile && typeof profile === "object" ? profile : void 0,
-    authenticated: Boolean(profile?.access_token),
-    email: typeof profile?.email === "string" ? profile.email : void 0,
-    expiresAt: typeof profile?.expires_at === "string" ? profile.expires_at : void 0,
-    profiles
-  };
-}
-function activateCloudProfile({ backend, apiUrl, env = process.env, platform = process.platform } = {}) {
-  const targetApiUrl = resolveApiUrl({ backend, apiUrl, env });
-  const config = loadCloudConfig(env, platform);
-  const profiles = config.profiles && typeof config.profiles === "object" ? config.profiles : {};
-  const profile = profiles[targetApiUrl];
-  if (!profile || typeof profile !== "object" || !profile.access_token) {
-    return {
-      apiUrl: targetApiUrl,
-      activeApiUrl: typeof config.active_api_url === "string" ? config.active_api_url : void 0,
-      authenticated: false,
-      activated: false,
-      profiles
-    };
+function findManifestFiles(root, { maxDepth, maxDirs, limit }) {
+  const manifests = [];
+  const stack = [{ dir: root, depth: 0 }];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length && manifests.length < limit && seen.size < maxDirs) {
+    const { dir, depth } = stack.pop();
+    const resolved = safeResolve(dir);
+    if (!resolved || seen.has(resolved)) {
+      continue;
+    }
+    seen.add(resolved);
+    let entries;
+    try {
+      entries = fs5.readdirSync(resolved, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && MANIFEST_NAMES.has(entry.name)) {
+        manifests.push(path4.join(resolved, entry.name));
+        if (manifests.length >= limit) {
+          break;
+        }
+      }
+    }
+    if (depth >= maxDepth) {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) {
+        continue;
+      }
+      stack.push({ dir: path4.join(resolved, entry.name), depth: depth + 1 });
+    }
   }
-  const next = {
-    ...config,
-    version: config.version || 2,
-    profiles,
-    active_api_url: targetApiUrl
-  };
-  writeCloudConfig(next, { env, platform });
-  return {
-    apiUrl: targetApiUrl,
-    activeApiUrl: targetApiUrl,
-    profile,
-    authenticated: true,
-    activated: true,
-    email: typeof profile.email === "string" ? profile.email : void 0,
-    expiresAt: typeof profile.expires_at === "string" ? profile.expires_at : void 0,
-    profiles
-  };
-}
-async function getOAuthConfig(apiUrl, redirectUri) {
-  const url = new URL(`${apiUrl}/api/v1/cli/auth/oauth/config`);
-  url.searchParams.set("redirectUri", redirectUri);
-  return getJson(url);
-}
-function authorizationUrlFor(config, { state, codeChallenge }) {
-  const url = new URL(String(config.authorizationUrl));
-  url.searchParams.set("response_type", "code");
-  url.searchParams.set("client_id", String(config.clientId));
-  url.searchParams.set("redirect_uri", String(config.redirectUri));
-  url.searchParams.set("scope", String(config.scopes || "email profile"));
-  url.searchParams.set("state", state);
-  url.searchParams.set("code_challenge", codeChallenge);
-  url.searchParams.set("code_challenge_method", "S256");
-  return url.toString();
+  return manifests;
 }
-async function exchangeCodeForClerkToken(config, code, codeVerifier, redirectUri) {
-  const body = new URLSearchParams({
-    grant_type: "authorization_code",
-    client_id: String(config.clientId),
-    code,
-    redirect_uri: redirectUri,
-    code_verifier: codeVerifier
-  });
-  const payload = await postForm(String(config.tokenUrl), body);
-  const token = payload.access_token || payload.id_token;
-  if (!token) {
-    throw new Error("OAuth token exchange did not return a Clerk token");
+function nearestAgentsAncestor(manifestPath, root) {
+  let current = path4.dirname(manifestPath);
+  const stop = path4.resolve(root);
+  while (current.startsWith(stop)) {
+    if (path4.basename(current).toLowerCase() === "agents") {
+      return current;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
   }
-  return String(token);
+  return null;
 }
-async function getJson(url, headers = {}) {
-  const response = await fetch(url, { headers: { Accept: "application/json", ...headers } });
-  return decodeResponse(response);
+function hasDirectManifest(root) {
+  return [...MANIFEST_NAMES].some((name) => fs5.existsSync(path4.join(root, name)));
 }
-async function postJson(url, body) {
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { Accept: "application/json", "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  return decodeResponse(response);
+function displayPath(target, cwd) {
+  const relative = path4.relative(cwd, target);
+  if (!relative) {
+    return ".";
+  }
+  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+    return target;
+  }
+  return relative.startsWith(".") ? relative : `.${path4.sep}${relative}`;
 }
-async function postForm(url, body) {
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
-    body
-  });
-  return decodeResponse(response);
+function commonSearchRoots(home) {
+  if (!home) {
+    return [];
+  }
+  return [
+    "agents",
+    "Projects",
+    "Code",
+    "Developer",
+    "Documents",
+    "Desktop"
+  ].map((name) => path4.join(home, name));
 }
-async function decodeResponse(response) {
-  const text = await response.text();
-  let payload = {};
-  if (text) {
+function uniqueExistingDirs(paths) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of paths) {
+    const resolved = safeResolve(item);
+    if (!resolved || seen.has(resolved)) {
+      continue;
+    }
     try {
-      payload = JSON.parse(text);
+      if (!fs5.statSync(resolved).isDirectory()) {
+        continue;
+      }
     } catch {
-      payload = { error: text };
+      continue;
     }
+    seen.add(resolved);
+    result.push(resolved);
   }
-  if (!response.ok) {
-    throw new Error(payload.message || payload.error || `HTTP ${response.status}`);
-  }
-  return payload;
-}
-async function createCallbackServer(env) {
-  const port = Number(env.VENDIAN_CLI_OAUTH_REDIRECT_PORT || DEFAULT_OAUTH_REDIRECT_PORT);
-  let server;
-  let settled = false;
-  let timeout;
-  const waitPromise = new Promise((resolve, reject) => {
-    timeout = setTimeout(() => {
-      settled = true;
-      reject(new Error("OAuth login timed out before callback completed"));
-    }, 3e5);
-    server = http.createServer((req, res) => {
-      const url = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
-      const code = url.searchParams.get("code");
-      const state = url.searchParams.get("state");
-      const error = url.searchParams.get("error");
-      const body = code ? "Vendian CLI authentication complete. You can close this window." : "Vendian CLI authentication failed. Return to the terminal.";
-      res.writeHead(code ? 200 : 400, {
-        "Content-Type": "text/plain; charset=utf-8",
-        "Content-Length": Buffer.byteLength(body)
-      });
-      res.end(body);
-      clearTimeout(timeout);
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (error) {
-        reject(new Error(`OAuth login failed: ${error}`));
-        return;
-      }
-      if (!code) {
-        reject(new Error("OAuth callback did not include an authorization code"));
-        return;
-      }
-      resolve({ code, state });
-    });
-    server.on("error", reject);
-    server.listen(port, "127.0.0.1");
-  });
-  await new Promise((resolve, reject) => {
-    server.once("listening", resolve);
-    server.once("error", reject);
-  });
-  return {
-    redirectUri: `http://127.0.0.1:${server.address().port}/callback`,
-    wait: () => waitPromise,
-    close: () => new Promise((resolve) => server.close(resolve))
-  };
+  return result;
 }
-function openBrowser(url) {
-  const platform = process.platform;
-  if (platform === "win32") {
-    spawnSync3(...buildWindowsOpenCommand(url), { stdio: "ignore", shell: false });
-    return;
-  }
-  if (platform === "darwin") {
-    spawnSync3(...buildMacOpenCommand(url), { stdio: "ignore", shell: false });
-    return;
+function parentDirs(start, limit) {
+  const parents = [];
+  let current = path4.resolve(start);
+  for (let index = 0; index < limit; index += 1) {
+    const parent = path4.dirname(current);
+    if (!parent || parent === current) {
+      break;
+    }
+    parents.push(parent);
+    current = parent;
   }
-  spawnSync3(...buildLinuxOpenCommand(url), { stdio: "ignore", shell: false });
+  return parents;
 }
-function buildWindowsOpenCommand(url) {
-  return ["rundll32.exe", ["url.dll,FileProtocolHandler", String(url)]];
+function safeResolve(candidate) {
+  try {
+    return path4.resolve(candidate);
+  } catch {
+    return null;
+  }
 }
-function buildMacOpenCommand(url) {
-  return ["open", [String(url)]];
+
+// src/dev-server.js
+init_auth();
+init_constants();
+
+// src/forward.js
+import fs9 from "node:fs";
+
+// src/docs.js
+import fs7 from "node:fs";
+import path6 from "node:path";
+var DOC_WORKSPACES_KEY = "agentDocWorkspaces";
+function pathApi2(platform) {
+  return platform === "win32" ? path6.win32 : path6.posix;
 }
-function buildLinuxOpenCommand(url) {
-  return ["xdg-open", [String(url)]];
+function commandWritesAgentDocs(args = []) {
+  return args[0] === "init";
 }
-function cloudConfigPath(env = process.env, platform = process.platform) {
-  if (env.VENDIAN_CLOUD_CONFIG) {
-    return path5.resolve(env.VENDIAN_CLOUD_CONFIG);
+function initOutputDir(args = []) {
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--output-dir" || arg === "-o") {
+      return args[index + 1] || ".";
+    }
+    if (arg.startsWith("--output-dir=")) {
+      return arg.slice("--output-dir=".length) || ".";
+    }
   }
-  if (platform === "win32") {
-    const root2 = env.APPDATA || path5.join(process.env.USERPROFILE || "", "AppData", "Roaming");
-    return path5.win32.join(root2, "Vendian", "cloud-auth.json");
+  return ".";
+}
+function resolveWorkspacePath(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, {
+  env = process.env,
+  platform = process.platform,
+  cwd = process.cwd(),
+  now = /* @__PURE__ */ new Date()
+} = {}) {
+  const workspacePath = resolveWorkspacePath(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 next = {
+    ...config,
+    [DOC_WORKSPACES_KEY]: workspaces,
+    lastAgentDocsInitAt: now.toISOString()
+  };
+  saveConfig(next, env, platform);
+  return next;
+}
+function recordForwardedDocsCommand(args, code, options = {}) {
+  if (code !== 0 || !commandWritesAgentDocs(args)) {
+    return false;
   }
-  const root = env.XDG_CONFIG_HOME || path5.join(process.env.HOME || "", ".config");
-  return path5.posix.join(root, "vendian", "cloud-auth.json");
+  recordAgentDocsWorkspace(initOutputDir(args), options);
+  return true;
 }
-function saveCloudToken(token, { env = process.env, platform = process.platform } = {}) {
-  const tokenApiUrl = String(token.apiUrl || "").replace(/\/$/, "");
-  let raw = { version: 2, profiles: {}, active_api_url: token.apiUrl };
-  try {
-    const existing = loadCloudConfig(env, platform);
-    if (existing && typeof existing === "object" && existing.profiles && typeof existing.profiles === "object") {
-      raw.profiles = existing.profiles;
+function refreshAgentDocsWorkspaces({
+  config,
+  venvPath,
+  env = process.env,
+  platform = process.platform,
+  run: run2 = runInherit,
+  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) {
+    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)) {
+      continue;
+    }
+    const status = run2(vendianPath, ["init", "--output-dir", workspace, "--yes"]);
+    if (status === 0) {
+      refreshed += 1;
+    } else {
+      failed += 1;
+      console.error(`[vendian] Could not refresh SDK docs in ${workspace}`);
     }
-  } catch {
   }
-  raw.active_api_url = tokenApiUrl;
-  raw.profiles[tokenApiUrl] = {
-    api_url: tokenApiUrl,
-    access_token: token.accessToken,
-    user_id: token.userId,
-    email: token.email,
-    expires_at: token.expiresAt,
-    scopes: token.scopes,
-    tooling_eligible: token.toolingEligible
+  const next = {
+    ...currentConfig,
+    [DOC_WORKSPACES_KEY]: workspaces,
+    lastAgentDocsRefreshAt: now.toISOString()
   };
-  return writeCloudConfig(raw, { env, platform });
-}
-function writeCloudConfig(raw, { env = process.env, platform = process.platform } = {}) {
-  const file = cloudConfigPath(env, platform);
-  fs6.mkdirSync(path5.dirname(file), { recursive: true });
-  fs6.writeFileSync(file, `${JSON.stringify(raw, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-  try {
-    fs6.chmodSync(file, 384);
-  } catch {
-  }
-  return file;
+  saveConfig(next, env, platform);
+  return { config: next, refreshed, failed };
 }
 
 // src/setup.js
+init_auth();
+init_constants();
+import fs8 from "node:fs";
 async function setup({
   nonInteractive = false,
   backend = void 0,
@@ -868,474 +1141,290 @@ async function setup({
     if (registry.tokenSource !== "secret-store") {
       next.gitlabToken = registry.token;
     }
-    console.log("Using saved package access.");
-  }
-  const installRegistry = registryConfig(next, env, platform);
-  if (!installRegistry.token) {
-    throw new Error("Package access is missing. Run interactive `vendian login` to sign in.");
-  }
-  const python = findPython(platform);
-  if (!python) {
-    throw new Error("Python 3.11+ was not found. Install Python 3.11 or newer, then rerun `vendian login`.");
-  }
-  const venvPath = managedVenvPath(env, platform);
-  console.log(`Managed environment: ${venvPath}`);
-  const pythonPath = ensureVenv(venvPath, python, platform);
-  console.log(`Python: ${pythonVersion(pythonPath) || pythonPath}`);
-  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 });
-  if (!verifyVendianImports(pythonPath)) {
-    throw new Error("Vendian packages installed, but import verification failed.");
-  }
-  const vendianPath = venvVendian(venvPath, platform);
-  if (!fs7.existsSync(vendianPath)) {
-    throw new Error("Vendian executable was not found after install.");
-  }
-  console.log("");
-  for (const line of setupCompletionLines({ cloudAuthApiUrl, backend, apiUrl })) {
-    console.log(line);
-  }
-}
-function savePackageCredentials(config, packageCredentials, { platform = process.platform } = {}) {
-  if (!packageCredentials?.token) {
-    return false;
-  }
-  config.gitlabHost = packageCredentials.gitlabHost || config.gitlabHost;
-  config.gitlabUsername = packageCredentials.username || config.gitlabUsername;
-  config.sdkPublicProjectId = packageCredentials.sdkProjectId || config.sdkPublicProjectId;
-  config.sdkRuntimeProjectId = packageCredentials.runtimeProjectId || config.sdkRuntimeProjectId;
-  config.vendianAgentsVersion = packageCredentials.vendianAgentsVersion || config.vendianAgentsVersion;
-  config.vendianAgentsRuntimeVersion = packageCredentials.vendianAgentsRuntimeVersion || config.vendianAgentsRuntimeVersion;
-  const secret = savePackageTokenSecret(packageCredentials.token, config, platform);
-  if (secret.ok) {
-    Object.assign(config, secret.config || {});
-    delete config.gitlabToken;
-    console.log("Package access saved.");
-  } else {
-    config.gitlabToken = packageCredentials.token;
-    console.log("Package access saved in the local Vendian CLI config file.");
-  }
-  return true;
-}
-async function refreshPackageAccessFromCloudAuth({
-  config,
-  auth,
-  env = process.env,
-  platform = process.platform,
-  save = true
-} = {}) {
-  const currentConfig = config || loadConfig(env, platform);
-  const registry = registryConfig(currentConfig, env, platform);
-  if (registry.token) {
-    return { config: currentConfig, refreshed: false };
-  }
-  const status = auth || activeCloudAuthStatus({ env, platform });
-  if (!status.authenticated || !status.apiUrl || !status.profile?.access_token) {
-    return { config: currentConfig, refreshed: false };
-  }
-  const packageCredentials = await fetchPackageCredentials({
-    apiUrl: status.apiUrl,
-    accessToken: status.profile.access_token
-  });
-  if (!packageCredentials?.token) {
-    return { config: currentConfig, refreshed: false };
-  }
-  const next = { ...currentConfig };
-  const stored = savePackageCredentials(next, packageCredentials, { platform });
-  if (stored && save) {
-    saveConfig(next, env, platform);
-  }
-  return { config: next, refreshed: stored };
-}
-function setupCompletionLines({ cloudAuthApiUrl, backend, apiUrl } = {}) {
-  const lines = ["Vendian login complete."];
-  if (cloudAuthApiUrl) {
-    lines.push(`Connected to ${cloudAuthApiUrl}.`);
-    lines.push("Next: vendian cloud local serve --agents-dir ./agents");
-    return lines;
-  }
-  lines.push(`Next: ${cloudAuthLoginCommand({ backend, apiUrl })}`);
-  lines.push("Then: vendian cloud local serve --agents-dir ./agents");
-  return lines;
-}
-function cloudAuthLoginCommand({ backend, apiUrl } = {}) {
-  if (apiUrl) {
-    return `vendian cloud auth login --api-url ${apiUrl}`;
-  }
-  if (backend) {
-    return `vendian cloud auth login --backend ${backend}`;
-  }
-  return "vendian cloud auth login";
-}
-
-// src/forward.js
-var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-async function forwardToPythonVendian(args, { env = process.env, platform = process.platform } = {}) {
-  const invocation = await preparePythonVendianInvocation(args, { env, platform });
-  const code = await spawnForward(invocation.command, invocation.args, {
-    env: invocation.env
-  });
-  recordForwardedDocsCommand(args, code, { env, platform });
-  process.exitCode = code;
-}
-async function preparePythonVendianInvocation(args, {
-  env = process.env,
-  platform = process.platform,
-  onProgress = null,
-  skipAutoUpdate = false
-} = {}) {
-  const venvPath = managedVenvPath(env, platform);
-  const vendianPath = venvVendian(venvPath, platform);
-  reportProgress(onProgress, "Checking managed Python runtime");
-  if (!fs8.existsSync(vendianPath)) {
-    throw new Error("Vendian is not set up yet. Run `vendian login` first.");
-  }
-  const loadedConfig = loadConfig(env, platform);
-  const requiresPackageAccess = commandNeedsPackageAccess(args);
-  if (requiresPackageAccess) {
-    reportProgress(onProgress, "Refreshing package access");
-  }
-  const refreshed = requiresPackageAccess ? await refreshPackageAccessFromCloudAuth({ config: loadedConfig, env, platform }) : { config: loadedConfig };
-  if (!skipAutoUpdate) {
-    maybeAutoUpdateManagedEnv({ env, platform, venvPath, onProgress });
-  }
-  const config = refreshed.config;
-  reportProgress(onProgress, "Preparing package indexes");
-  const registry = registryConfig(config, env, platform);
-  if (requiresPackageAccess && !registry.token) {
-    throw new Error("Package access is missing. Run `vendian login` or `vendian update` before starting local agents.");
-  }
-  reportProgress(onProgress, "Launching local serve daemon");
-  return {
-    command: vendianPath,
-    args,
-    env: {
-      ...env,
-      ...packageIndexEnv(config, env, platform)
-    }
-  };
-}
-function commandNeedsPackageAccess(args = []) {
-  return args[0] === "cloud" && args[1] === "local" && ["serve", "run"].includes(args[2]);
-}
-function packageIndexEnv(config = {}, env = process.env, platform = process.platform) {
-  const registry = registryConfig(config, env, platform);
-  const indexes = buildIndexUrls(registry);
-  if (!indexes) {
-    return {};
-  }
-  const extraIndexUrls = joinIndexUrls([
-    indexes.runtimeIndexUrl,
-    "https://pypi.org/simple",
-    env.VENDIAN_PIP_EXTRA_INDEX_URL
-  ]);
-  const uvExtraIndexUrls = joinIndexUrls([
-    indexes.runtimeIndexUrl,
-    "https://pypi.org/simple",
-    env.VENDIAN_UV_EXTRA_INDEX_URL
-  ]);
-  return {
-    VENDIAN_PIP_INDEX_URL: indexes.sdkIndexUrl,
-    VENDIAN_PIP_EXTRA_INDEX_URL: extraIndexUrls,
-    VENDIAN_UV_INDEX_URL: indexes.sdkIndexUrl,
-    VENDIAN_UV_EXTRA_INDEX_URL: uvExtraIndexUrls
-  };
-}
-function joinIndexUrls(urls) {
-  return urls.flatMap((value) => String(value || "").split(/\s+/)).map((value) => value.trim()).filter(Boolean).filter((value, index, all) => all.indexOf(value) === index).join(" ");
-}
-function maybeAutoUpdateManagedEnv({
-  env = process.env,
-  platform = process.platform,
-  venvPath = managedVenvPath(env, platform),
-  force = false,
-  log = true,
-  load = loadConfig,
-  save = saveConfig,
-  installPackages = installVendianPackages,
-  refreshDocs = refreshAgentDocsWorkspaces,
-  now = Date.now(),
-  onProgress = null
-} = {}) {
-  if (env.VENDIAN_SKIP_AUTO_UPDATE === "1") {
-    return false;
+    console.log("Using saved package access.");
   }
-  const config = load(env, platform);
-  const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
-  if (!force && Number.isFinite(lastUpdate) && now - lastUpdate < AUTO_UPDATE_INTERVAL_MS) {
-    return false;
+  const installRegistry = registryConfig(next, env, platform);
+  if (!installRegistry.token) {
+    throw new Error("Package access is missing. Run interactive `vendian login` to sign in.");
   }
-  const registry = registryConfig(config, env, platform);
-  if (!registry.token) {
-    return false;
+  const python = findPython(platform);
+  if (!python) {
+    throw new Error("Python 3.11+ was not found. Install Python 3.11 or newer, then rerun `vendian login`.");
   }
-  const pythonPath = venvPython(venvPath, platform);
-  if (!fs8.existsSync(pythonPath)) {
-    return false;
+  const venvPath = managedVenvPath(env, platform);
+  console.log(`Managed environment: ${venvPath}`);
+  const pythonPath = ensureVenv(venvPath, python, platform);
+  console.log(`Python: ${pythonVersion(pythonPath) || pythonPath}`);
+  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 });
+  if (!verifyVendianImports(pythonPath)) {
+    throw new Error("Vendian packages installed, but import verification failed.");
   }
-  try {
-    if (log) {
-      console.error("[vendian] Checking managed CLI/runtime updates...");
-    }
-    reportProgress(onProgress, "Installing managed CLI/runtime updates");
-    installPackages({ pythonPath, venvPath, config, env, platform });
-    const next = { ...config, lastManagedUpdateAt: new Date(now).toISOString() };
-    save(next, env, platform);
-    reportProgress(onProgress, "Refreshing generated agent docs");
-    refreshDocs({ config: next, venvPath, env, platform });
-    reportProgress(onProgress, "Managed CLI/runtime ready");
-    return true;
-  } catch (error) {
-    const message = error && typeof error.message === "string" ? error.message : String(error);
-    if (log) {
-      console.error(`[vendian] Update check failed; continuing with installed CLI. ${message}`);
-    }
-    return false;
+  const vendianPath = venvVendian(venvPath, platform);
+  if (!fs8.existsSync(vendianPath)) {
+    throw new Error("Vendian executable was not found after install.");
+  }
+  console.log("");
+  for (const line of setupCompletionLines({ cloudAuthApiUrl, backend, apiUrl })) {
+    console.log(line);
   }
 }
-function reportProgress(onProgress, message) {
-  if (typeof onProgress === "function") {
-    onProgress(message);
+function savePackageCredentials(config, packageCredentials, { platform = process.platform } = {}) {
+  if (!packageCredentials?.token) {
+    return false;
+  }
+  config.gitlabHost = packageCredentials.gitlabHost || config.gitlabHost;
+  config.gitlabUsername = packageCredentials.username || config.gitlabUsername;
+  config.sdkPublicProjectId = packageCredentials.sdkProjectId || config.sdkPublicProjectId;
+  config.sdkRuntimeProjectId = packageCredentials.runtimeProjectId || config.sdkRuntimeProjectId;
+  config.vendianAgentsVersion = packageCredentials.vendianAgentsVersion || config.vendianAgentsVersion;
+  config.vendianAgentsRuntimeVersion = packageCredentials.vendianAgentsRuntimeVersion || config.vendianAgentsRuntimeVersion;
+  const secret = savePackageTokenSecret(packageCredentials.token, config, platform);
+  if (secret.ok) {
+    Object.assign(config, secret.config || {});
+    delete config.gitlabToken;
+    console.log("Package access saved.");
+  } else {
+    config.gitlabToken = packageCredentials.token;
+    console.log("Package access saved in the local Vendian CLI config file.");
   }
+  return true;
 }
-
-// src/tui.js
-import fs11 from "node:fs";
-import path8 from "node:path";
-import readline from "node:readline";
-
-// src/version.js
-var CLI_VERSION = true ? "0.0.33" : process.env.npm_package_version || "0.0.0-dev";
-
-// src/npm-update.js
-var NPM_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
-
-// src/agent-discovery.js
-import fs9 from "node:fs";
-import os2 from "node:os";
-import path6 from "node:path";
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  ".agents",
-  ".git",
-  ".hg",
-  ".mypy_cache",
-  ".pytest_cache",
-  ".ruff_cache",
-  ".svn",
-  ".venv",
-  "__pycache__",
-  "build",
-  "dist",
-  "node_modules",
-  "venv"
-]);
-var MANIFEST_NAMES = /* @__PURE__ */ new Set(["manifest.yaml", "manifest.yml"]);
-function findAgentDirectoryCandidates({
-  cwd = process.cwd(),
-  home = os2.homedir(),
-  maxDepth = 6,
-  maxDirs = 1e3,
-  limit = 12
+async function refreshPackageAccessFromCloudAuth({
+  config,
+  auth,
+  env = process.env,
+  platform = process.platform,
+  save = true
 } = {}) {
-  const start = path6.resolve(cwd);
-  const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
-  function addCandidate(candidatePath) {
-    const resolved = safeResolve(candidatePath);
-    if (!resolved || seen.has(resolved)) {
-      return;
-    }
-    const count = countAgentManifests(resolved, { maxDepth, maxDirs, limit: 100 });
-    if (count < 1) {
-      return;
-    }
-    seen.add(resolved);
-    candidates.push({
-      path: displayPath(resolved, start),
-      absolutePath: resolved,
-      agentCount: count
-    });
+  const currentConfig = config || loadConfig(env, platform);
+  const registry = registryConfig(currentConfig, env, platform);
+  if (registry.token) {
+    return { config: currentConfig, refreshed: false };
   }
-  addCandidate(path6.join(start, "agents"));
-  if (hasDirectManifest(start)) {
-    addCandidate(start);
+  const status = auth || activeCloudAuthStatus({ env, platform });
+  if (!status.authenticated || !status.apiUrl || !status.profile?.access_token) {
+    return { config: currentConfig, refreshed: false };
   }
-  for (const parent of parentDirs(start, 3)) {
-    addCandidate(path6.join(parent, "agents"));
+  const packageCredentials = await fetchPackageCredentials({
+    apiUrl: status.apiUrl,
+    accessToken: status.profile.access_token
+  });
+  if (!packageCredentials?.token) {
+    return { config: currentConfig, refreshed: false };
   }
-  const roots = uniqueExistingDirs([
-    start,
-    ...commonSearchRoots(home)
-  ]);
-  for (const root of roots) {
-    for (const manifest of findManifestFiles(root, { maxDepth, maxDirs, limit: 250 })) {
-      const workspace = nearestAgentsAncestor(manifest, root);
-      addCandidate(workspace || path6.dirname(manifest));
-      if (candidates.length >= limit) {
-        return candidates.slice(0, limit);
-      }
-    }
+  const next = { ...currentConfig };
+  const stored = savePackageCredentials(next, packageCredentials, { platform });
+  if (stored && save) {
+    saveConfig(next, env, platform);
   }
-  return candidates.slice(0, limit);
+  return { config: next, refreshed: stored };
 }
-function findAgentFolders(root, {
-  cwd = process.cwd(),
-  maxDepth = 6,
-  maxDirs = 1e3,
-  limit = 100
-} = {}) {
-  const start = path6.resolve(cwd);
-  const resolvedRoot = safeResolve(root || ".");
-  if (!resolvedRoot) {
-    return [];
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const folders = [];
-  for (const manifest of findManifestFiles(resolvedRoot, { maxDepth, maxDirs, limit })) {
-    const folder = path6.dirname(manifest);
-    const resolved = safeResolve(folder);
-    if (!resolved || seen.has(resolved)) {
-      continue;
-    }
-    seen.add(resolved);
-    folders.push({
-      path: displayPath(resolved, start),
-      absolutePath: resolved,
-      name: path6.basename(resolved) || displayPath(resolved, start)
-    });
+function setupCompletionLines({ cloudAuthApiUrl, backend, apiUrl } = {}) {
+  const lines = ["Vendian login complete."];
+  if (cloudAuthApiUrl) {
+    lines.push(`Connected to ${cloudAuthApiUrl}.`);
+    lines.push("Next: vendian cloud local serve --agents-dir ./agents");
+    return lines;
   }
-  return folders.sort((a, b) => a.path.localeCompare(b.path)).slice(0, limit);
+  lines.push(`Next: ${cloudAuthLoginCommand({ backend, apiUrl })}`);
+  lines.push("Then: vendian cloud local serve --agents-dir ./agents");
+  return lines;
 }
-function countAgentManifests(root, { maxDepth = 6, maxDirs = 1e3, limit = 100 } = {}) {
-  let count = 0;
-  for (const _manifest of findManifestFiles(root, { maxDepth, maxDirs, limit })) {
-    count += 1;
-    if (count >= limit) {
-      return count;
-    }
+function cloudAuthLoginCommand({ backend, apiUrl } = {}) {
+  if (apiUrl) {
+    return `vendian cloud auth login --api-url ${apiUrl}`;
   }
-  return count;
-}
-function findManifestFiles(root, { maxDepth, maxDirs, limit }) {
-  const manifests = [];
-  const stack = [{ dir: root, depth: 0 }];
-  const seen = /* @__PURE__ */ new Set();
-  while (stack.length && manifests.length < limit && seen.size < maxDirs) {
-    const { dir, depth } = stack.pop();
-    const resolved = safeResolve(dir);
-    if (!resolved || seen.has(resolved)) {
-      continue;
-    }
-    seen.add(resolved);
-    let entries;
-    try {
-      entries = fs9.readdirSync(resolved, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.isFile() && MANIFEST_NAMES.has(entry.name)) {
-        manifests.push(path6.join(resolved, entry.name));
-        if (manifests.length >= limit) {
-          break;
-        }
-      }
-    }
-    if (depth >= maxDepth) {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) {
-        continue;
-      }
-      stack.push({ dir: path6.join(resolved, entry.name), depth: depth + 1 });
-    }
+  if (backend) {
+    return `vendian cloud auth login --backend ${backend}`;
   }
-  return manifests;
+  return "vendian cloud auth login";
+}
+
+// src/forward.js
+var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+async function forwardToPythonVendian(args, { env = process.env, platform = process.platform } = {}) {
+  const invocation = await preparePythonVendianInvocation(args, { env, platform });
+  const code = await spawnForward(invocation.command, invocation.args, {
+    env: invocation.env
+  });
+  recordForwardedDocsCommand(args, code, { env, platform });
+  process.exitCode = code;
 }
-function nearestAgentsAncestor(manifestPath, root) {
-  let current = path6.dirname(manifestPath);
-  const stop = path6.resolve(root);
-  while (current.startsWith(stop)) {
-    if (path6.basename(current).toLowerCase() === "agents") {
-      return current;
-    }
-    const parent = path6.dirname(current);
-    if (parent === current) {
-      break;
+async function preparePythonVendianInvocation(args, {
+  env = process.env,
+  platform = process.platform,
+  onProgress = null,
+  skipAutoUpdate = false
+} = {}) {
+  const venvPath = managedVenvPath(env, platform);
+  const vendianPath = venvVendian(venvPath, platform);
+  reportProgress(onProgress, "Checking managed Python runtime");
+  if (!fs9.existsSync(vendianPath)) {
+    throw new Error("Vendian is not set up yet. Run `vendian login` first.");
+  }
+  const loadedConfig = loadConfig(env, platform);
+  const requiresPackageAccess = commandNeedsPackageAccess(args);
+  if (requiresPackageAccess) {
+    reportProgress(onProgress, "Refreshing package access");
+  }
+  const refreshed = requiresPackageAccess ? await refreshPackageAccessFromCloudAuth({ config: loadedConfig, env, platform }) : { config: loadedConfig };
+  if (!skipAutoUpdate) {
+    maybeAutoUpdateManagedEnv({ env, platform, venvPath, onProgress });
+  }
+  const config = refreshed.config;
+  reportProgress(onProgress, "Preparing package indexes");
+  const registry = registryConfig(config, env, platform);
+  if (requiresPackageAccess && !registry.token) {
+    throw new Error("Package access is missing. Run `vendian login` or `vendian update` before starting local agents.");
+  }
+  reportProgress(onProgress, "Launching local serve daemon");
+  return {
+    command: vendianPath,
+    args,
+    env: {
+      ...env,
+      ...packageIndexEnv(config, env, platform)
     }
-    current = parent;
+  };
+}
+function commandNeedsPackageAccess(args = []) {
+  return args[0] === "cloud" && args[1] === "local" && ["serve", "run"].includes(args[2]);
+}
+function packageIndexEnv(config = {}, env = process.env, platform = process.platform) {
+  const registry = registryConfig(config, env, platform);
+  const indexes = buildIndexUrls(registry);
+  if (!indexes) {
+    return {};
   }
-  return null;
+  const extraIndexUrls = joinIndexUrls([
+    indexes.runtimeIndexUrl,
+    "https://pypi.org/simple",
+    env.VENDIAN_PIP_EXTRA_INDEX_URL
+  ]);
+  const uvExtraIndexUrls = joinIndexUrls([
+    indexes.runtimeIndexUrl,
+    "https://pypi.org/simple",
+    env.VENDIAN_UV_EXTRA_INDEX_URL
+  ]);
+  return {
+    VENDIAN_PIP_INDEX_URL: indexes.sdkIndexUrl,
+    VENDIAN_PIP_EXTRA_INDEX_URL: extraIndexUrls,
+    VENDIAN_UV_INDEX_URL: indexes.sdkIndexUrl,
+    VENDIAN_UV_EXTRA_INDEX_URL: uvExtraIndexUrls
+  };
 }
-function hasDirectManifest(root) {
-  return [...MANIFEST_NAMES].some((name) => fs9.existsSync(path6.join(root, name)));
+function joinIndexUrls(urls) {
+  return urls.flatMap((value) => String(value || "").split(/\s+/)).map((value) => value.trim()).filter(Boolean).filter((value, index, all) => all.indexOf(value) === index).join(" ");
 }
-function displayPath(target, cwd) {
-  const relative = path6.relative(cwd, target);
-  if (!relative) {
-    return ".";
+function maybeAutoUpdateManagedEnv({
+  env = process.env,
+  platform = process.platform,
+  venvPath = managedVenvPath(env, platform),
+  force = false,
+  log = true,
+  load = loadConfig,
+  save = saveConfig,
+  installPackages = installVendianPackages,
+  refreshDocs = refreshAgentDocsWorkspaces,
+  now = Date.now(),
+  onProgress = null
+} = {}) {
+  if (env.VENDIAN_SKIP_AUTO_UPDATE === "1") {
+    return false;
   }
-  if (relative.startsWith("..") || path6.isAbsolute(relative)) {
-    return target;
+  const config = load(env, platform);
+  const lastUpdate = Date.parse(config.lastManagedUpdateAt || "");
+  if (!force && Number.isFinite(lastUpdate) && now - lastUpdate < AUTO_UPDATE_INTERVAL_MS) {
+    return false;
   }
-  return relative.startsWith(".") ? relative : `.${path6.sep}${relative}`;
-}
-function commonSearchRoots(home) {
-  if (!home) {
-    return [];
+  const registry = registryConfig(config, env, platform);
+  if (!registry.token) {
+    return false;
   }
-  return [
-    "agents",
-    "Projects",
-    "Code",
-    "Developer",
-    "Documents",
-    "Desktop"
-  ].map((name) => path6.join(home, name));
-}
-function uniqueExistingDirs(paths) {
-  const result = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const item of paths) {
-    const resolved = safeResolve(item);
-    if (!resolved || seen.has(resolved)) {
-      continue;
+  const pythonPath = venvPython(venvPath, platform);
+  if (!fs9.existsSync(pythonPath)) {
+    return false;
+  }
+  try {
+    if (log) {
+      console.error("[vendian] Checking managed CLI/runtime updates...");
     }
-    try {
-      if (!fs9.statSync(resolved).isDirectory()) {
-        continue;
-      }
-    } catch {
-      continue;
+    reportProgress(onProgress, "Installing managed CLI/runtime updates");
+    installPackages({ pythonPath, venvPath, config, env, platform });
+    const next = { ...config, lastManagedUpdateAt: new Date(now).toISOString() };
+    save(next, env, platform);
+    reportProgress(onProgress, "Refreshing generated agent docs");
+    refreshDocs({ config: next, venvPath, env, platform });
+    reportProgress(onProgress, "Managed CLI/runtime ready");
+    return true;
+  } catch (error) {
+    const message = error && typeof error.message === "string" ? error.message : String(error);
+    if (log) {
+      console.error(`[vendian] Update check failed; continuing with installed CLI. ${message}`);
     }
-    seen.add(resolved);
-    result.push(resolved);
+    return false;
   }
-  return result;
 }
-function parentDirs(start, limit) {
-  const parents = [];
-  let current = path6.resolve(start);
-  for (let index = 0; index < limit; index += 1) {
-    const parent = path6.dirname(current);
-    if (!parent || parent === current) {
-      break;
-    }
-    parents.push(parent);
-    current = parent;
+function reportProgress(onProgress, message) {
+  if (typeof onProgress === "function") {
+    onProgress(message);
   }
-  return parents;
 }
-function safeResolve(candidate) {
+
+// src/workspaces.js
+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 path6.resolve(candidate);
-  } catch {
-    return null;
+    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() {
@@ -1392,14 +1481,14 @@ function applyServeEvent(state, event) {
     logs: appendLog(state.logs, event)
   };
   if (event.type === "workspace_resolved") {
-    return { ...next, collectionId: stringValue(event.collectionId), activity: "Workspace resolved" };
+    return { ...next, collectionId: stringValue2(event.collectionId), activity: "Workspace resolved" };
   }
   if (event.type === "daemon_registered") {
     return {
       ...next,
       connected: true,
-      daemonId: stringValue(event.daemonId),
-      cliSessionId: stringValue(event.cliSessionId),
+      daemonId: stringValue2(event.daemonId),
+      cliSessionId: stringValue2(event.cliSessionId),
       activity: "Daemon registered"
     };
   }
@@ -1419,7 +1508,7 @@ function applyServeEvent(state, event) {
     };
   }
   if (event.type === "daemon_wake_received") {
-    const sourceType = stringValue(event.sourceEventType || "backend wake");
+    const sourceType = stringValue2(event.sourceEventType || "backend wake");
     return {
       ...next,
       activity: `Wake received: ${sourceType}`
@@ -1434,17 +1523,17 @@ function applyServeEvent(state, event) {
   if (event.type === "dispatch_job_received") {
     return {
       ...next,
-      activity: `Dispatch received for run ${stringValue(event.runId || event.sessionId || "unknown")}`
+      activity: `Dispatch received for run ${stringValue2(event.runId || event.sessionId || "unknown")}`
     };
   }
   if (event.type === "dispatch_job_acked") {
     return {
       ...next,
-      activity: `Dispatch acknowledged for run ${stringValue(event.runId || event.sessionId || "unknown")}`
+      activity: `Dispatch acknowledged for run ${stringValue2(event.runId || event.sessionId || "unknown")}`
     };
   }
   if (event.type === "daemon_stderr") {
-    const message = stringValue(event.message || event.stderr || "Daemon wrote to stderr");
+    const message = stringValue2(event.message || event.stderr || "Daemon wrote to stderr");
     return {
       ...next,
       activity: `Daemon stderr: ${message}`,
@@ -1489,14 +1578,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 = stringValue(event.message || event.stage || "Preparing agent");
+    const message = stringValue2(event.message || event.stage || "Preparing agent");
     return {
       ...next,
       agentLogs: appendAgentLog(state.agentLogs, event),
       agentRunState: setAgentRunState(state.agentRunState, relativePath, {
         status: "preparing",
         lastEventAt: timestamp,
-        progressStage: stringValue(event.stage),
+        progressStage: stringValue2(event.stage),
         progressMessage: message
       }),
       activity: `${relativePath}: ${message}`
@@ -1508,11 +1597,11 @@ function applyServeEvent(state, event) {
     const runState = isError ? setAgentRunState(state.agentRunState, agentLabel(event), {
       status: "error",
       lastEventAt: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-      errorMessage: stringValue(event.error || event.errorMessage || "Agent setup failed")
+      errorMessage: stringValue2(event.error || event.errorMessage || "Agent setup failed")
     }) : isDisabled ? setAgentRunState(state.agentRunState, agentLabel(event), {
       status: "disabled",
       lastEventAt: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-      disabledReason: stringValue(event.disabledReason || event.warning || "System dependency not met"),
+      disabledReason: stringValue2(event.disabledReason || event.warning || "System dependency not met"),
       resolutionHints: Array.isArray(event.resolutionHints) ? event.resolutionHints : []
     }) : setAgentRunState(state.agentRunState, agentLabel(event), {
       status: "ready",
@@ -1548,8 +1637,8 @@ function applyServeEvent(state, event) {
       agentLogs: appendAgentLog(state.agentLogs, event),
       agentRunState: setAgentRunState(state.agentRunState, relativePath, {
         status: "running",
-        runId: stringValue(event.runId || event.deployRequestId),
-        jobType: stringValue(event.jobType || "run"),
+        runId: stringValue2(event.runId || event.deployRequestId),
+        jobType: stringValue2(event.jobType || "run"),
         startedAt: timestamp,
         completedAt: null,
         lastEventAt: timestamp,
@@ -1563,7 +1652,7 @@ function applyServeEvent(state, event) {
     const relativePath = agentLabel(event);
     const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
     const success = event.success !== false;
-    const runId = stringValue(event.runId || event.deployRequestId);
+    const runId = stringValue2(event.runId || event.deployRequestId);
     const previous = (state.agentRunState || {})[relativePath];
     const effectiveSuccess = success && !(previous?.status === "error" && previous?.runId === runId);
     return {
@@ -1572,10 +1661,10 @@ function applyServeEvent(state, event) {
       agentRunState: setAgentRunState(state.agentRunState, relativePath, {
         status: effectiveSuccess ? "completed" : "error",
         runId,
-        jobType: stringValue(event.jobType || "run"),
+        jobType: stringValue2(event.jobType || "run"),
         completedAt: timestamp,
         lastEventAt: timestamp,
-        errorMessage: effectiveSuccess ? null : previous?.errorMessage || stringValue(event.error || "Job failed")
+        errorMessage: effectiveSuccess ? null : previous?.errorMessage || stringValue2(event.error || "Job failed")
       }),
       jobsRun: state.jobsRun + 1,
       currentJob: null,
@@ -1583,13 +1672,13 @@ function applyServeEvent(state, event) {
     };
   }
   if (event.type === "backend_connection_lost") {
-    return { ...next, connected: false, activity: `Connection lost during ${stringValue(event.activity)}`, retry: event };
+    return { ...next, connected: false, activity: `Connection lost during ${stringValue2(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 ${stringValue(event.activity)} in ${formatSeconds(event.delaySeconds)}` };
+    return { ...next, retry: event, activity: `Retrying ${stringValue2(event.activity)} in ${formatSeconds(event.delaySeconds)}` };
   }
   if (event.type === "error") {
     const relativePath = event.relativePath || event.path ? agentLabel(event) : "";
@@ -1600,11 +1689,11 @@ function applyServeEvent(state, event) {
       agentLogs: hasAgentScope ? appendAgentLog(state.agentLogs, event) : state.agentLogs,
       agentRunState: hasAgentScope ? setAgentRunState(state.agentRunState, relativePath, {
         status: "error",
-        runId: stringValue(event.runId || event.deployRequestId),
-        jobType: stringValue(event.jobType || "run"),
+        runId: stringValue2(event.runId || event.deployRequestId),
+        jobType: stringValue2(event.jobType || "run"),
         completedAt: timestamp,
         lastEventAt: timestamp,
-        errorMessage: stringValue(event.error || event.code || "Unknown error")
+        errorMessage: stringValue2(event.error || event.code || "Unknown error")
       }) : state.agentRunState,
       activity: "Error",
       errors: appendError(state.errors, jobLabel(event), event.error || event.code || "Unknown error")
@@ -1622,8 +1711,8 @@ function applyServeEvent(state, event) {
   }
   if (event.type === "process_exit" || event.type === "daemon_exit") {
     const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-    const message = stringValue(event.message || processExitMessage(event));
-    const relativePath = stringValue(event.relativePath || "");
+    const message = stringValue2(event.message || processExitMessage(event));
+    const relativePath = stringValue2(event.relativePath || "");
     const runState = failRunningAgents(state.agentRunState, message, timestamp, relativePath);
     return {
       ...next,
@@ -1678,7 +1767,7 @@ function mergeAgentLogRecords(agentLogs, records = []) {
   let next = agentLogs || {};
   for (const record of records) {
     if (!record || typeof record !== "object") continue;
-    const relativePath = stringValue(record.relativePath || ".");
+    const relativePath = stringValue2(record.relativePath || ".");
     const entry = record.entry && typeof record.entry === "object" ? record.entry : record;
     const existing = next[relativePath] || [];
     next = {
@@ -1693,13 +1782,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 = stringValue(entry.runId);
+      const runId = stringValue2(entry.runId);
       const current = next[relativePath] || {};
       if (entry.eventType === "job_started") {
         next = setAgentRunState(next, relativePath, {
           status: includeRunning ? "running" : current.status,
           runId,
-          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
+          jobType: entry.jobType ? stringValue2(entry.jobType) : current.jobType,
           startedAt: timestamp,
           lastEventAt: timestamp
         });
@@ -1710,10 +1799,10 @@ function agentRunStateFromLogs(agentLogs, { includeRunning = true } = {}) {
         next = setAgentRunState(next, relativePath, {
           status: failed ? "error" : "completed",
           runId,
-          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
+          jobType: entry.jobType ? stringValue2(entry.jobType) : current.jobType,
           completedAt: timestamp,
           lastEventAt: timestamp,
-          errorMessage: failed ? formatErrorMessage(entry.error) || current.errorMessage || stringValue(entry.message || "Job failed") : null
+          errorMessage: failed ? formatErrorMessage(entry.error) || current.errorMessage || stringValue2(entry.message || "Job failed") : null
         });
         continue;
       }
@@ -1721,10 +1810,10 @@ function agentRunStateFromLogs(agentLogs, { includeRunning = true } = {}) {
         next = setAgentRunState(next, relativePath, {
           status: "error",
           runId,
-          jobType: entry.jobType ? stringValue(entry.jobType) : current.jobType,
+          jobType: entry.jobType ? stringValue2(entry.jobType) : current.jobType,
           completedAt: timestamp,
           lastEventAt: timestamp,
-          errorMessage: formatErrorMessage(entry.error) || stringValue(entry.message || "Job failed")
+          errorMessage: formatErrorMessage(entry.error) || stringValue2(entry.message || "Job failed")
         });
         continue;
       }
@@ -1742,34 +1831,34 @@ function serveEventAgentLogEntry(event) {
   if (!event || typeof event !== "object") {
     return null;
   }
-  const type = stringValue(event.type);
-  const relativePath = stringValue(event.relativePath || event.path || ".");
+  const type = stringValue2(event.type);
+  const relativePath = stringValue2(event.relativePath || event.path || ".");
   const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
   if (type === "run_log") {
     return {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue(event.runId),
-        eventType: stringValue(event.eventType || "log"),
-        level: stringValue(event.level || "info"),
-        message: stringValue(event.message),
-        stepId: event.stepId ? stringValue(event.stepId) : null,
+        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,
         current: event.current ?? null,
         total: event.total ?? null,
         success: event.success ?? null,
         error: event.error ?? null,
-        jobType: event.jobType ? stringValue(event.jobType) : null
+        jobType: event.jobType ? stringValue2(event.jobType) : null
       }
     };
   }
   if (type === "job_started") {
-    const jobType = stringValue(event.jobType || "run");
+    const jobType = stringValue2(event.jobType || "run");
     return {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue(event.runId || event.deployRequestId),
+        runId: stringValue2(event.runId || event.deployRequestId),
         eventType: "job_started",
         level: "info",
         message: `Started ${jobType}`,
@@ -1784,15 +1873,15 @@ function serveEventAgentLogEntry(event) {
   }
   if (type === "job_completed") {
     const success = event.success !== false;
-    const jobType = stringValue(event.jobType || "run");
+    const jobType = stringValue2(event.jobType || "run");
     return {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue(event.runId || event.deployRequestId),
+        runId: stringValue2(event.runId || event.deployRequestId),
         eventType: "job_completed",
         level: success ? "info" : "error",
-        message: success ? "Completed successfully" : stringValue(event.error || "Failed"),
+        message: success ? "Completed successfully" : stringValue2(event.error || "Failed"),
         stepId: null,
         current: null,
         total: null,
@@ -1807,16 +1896,16 @@ function serveEventAgentLogEntry(event) {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue(event.runId || event.deployRequestId),
+        runId: stringValue2(event.runId || event.deployRequestId),
         eventType: "error",
         level: "error",
-        message: stringValue(event.error || event.code || "Unknown error"),
+        message: stringValue2(event.error || event.code || "Unknown error"),
         stepId: null,
         current: null,
         total: null,
         success: false,
         error: event.error ?? event.code ?? null,
-        jobType: event.jobType ? stringValue(event.jobType) : null
+        jobType: event.jobType ? stringValue2(event.jobType) : null
       }
     };
   }
@@ -1830,7 +1919,7 @@ function serveEventAgentLogEntry(event) {
         eventType: type,
         level: event.status === "error" ? "error" : "info",
         message: agentPrepareLogMessage(event),
-        stepId: stringValue(event.stage || type),
+        stepId: stringValue2(event.stage || type),
         current: null,
         total: null,
         success,
@@ -1840,12 +1929,12 @@ function serveEventAgentLogEntry(event) {
     };
   }
   if (type === "process_exit" || type === "daemon_exit") {
-    const message = stringValue(event.message || processExitMessage(event));
+    const message = stringValue2(event.message || processExitMessage(event));
     return {
       relativePath,
       entry: {
         timestamp,
-        runId: stringValue(event.runId || event.sessionId || "daemon"),
+        runId: stringValue2(event.runId || event.sessionId || "daemon"),
         eventType: type,
         level: "error",
         message,
@@ -1859,35 +1948,65 @@ function serveEventAgentLogEntry(event) {
           signal: event.signal ?? null,
           stderrTail: event.stderrTail ?? null
         },
-        jobType: event.jobType ? stringValue(event.jobType) : null
+        jobType: event.jobType ? stringValue2(event.jobType) : null
       }
     };
   }
   return null;
 }
+function agentRuntimeStatus(agent, agentRunState = {}) {
+  const path10 = stringValue2(agent?.relativePath || ".");
+  const run2 = (agentRunState || {})[path10];
+  const inventoryStatus = stringValue2(agent?.status);
+  if (run2?.status === "running") {
+    return { status: "running", label: "running", run: run2 };
+  }
+  if (run2?.status === "preparing") {
+    return { status: "preparing", label: "preparing", run: run2 };
+  }
+  if (run2?.status === "error" || inventoryStatus === "error") {
+    return { status: "error", label: "error", run: run2 };
+  }
+  if (run2?.status === "disabled" || inventoryStatus === "disabled") {
+    return {
+      status: "disabled",
+      label: "disabled",
+      run: run2,
+      disabledReason: run2?.disabledReason || agent?.disabledReason || "System dependency not met locally",
+      resolutionHints: run2?.resolutionHints || agent?.resolutionHints || []
+    };
+  }
+  if (inventoryStatus === "online") {
+    return { status: run2?.status === "completed" ? "completed" : "ready", label: "ready", run: run2 };
+  }
+  if (run2?.status === "completed") {
+    return { status: "completed", label: "ready", run: run2 };
+  }
+  return { status: inventoryStatus || "unknown", label: inventoryStatus || "unknown", run: run2 };
+}
 function appendError(errors, scope, message) {
-  return [...errors, { scope, message: stringValue(message) }].slice(-20);
+  return [...errors, { scope, message: stringValue2(message) }].slice(-20);
 }
 function serveDebugEntry(event) {
   if (!event || typeof event !== "object") return null;
-  const type = stringValue(event.type);
+  const type = stringValue2(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=${stringValue(event.collectionId || "unknown")}` };
+      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=${stringValue(event.error || "unknown")}` };
+      return { ...base, level: "warn", message: `daemon event stream lost retry=${formatSeconds(event.retryInSeconds)} error=${stringValue2(event.error || "unknown")}` };
     case "daemon_wake_received":
       return {
         ...base,
         message: [
-          `wake received source=${stringValue(event.sourceEventType || "backend")}`,
-          event.eventType ? `event=${stringValue(event.eventType)}` : "",
+          `wake received source=${stringValue2(event.sourceEventType || "backend")}`,
+          event.eventType ? `event=${stringValue2(event.eventType)}` : "",
           event.sessionId ? `session=${shortId(event.sessionId)}` : "",
           event.runId ? `run=${shortId(event.runId)}` : "",
           event.localAgentRowId ? `agentRow=${shortId(event.localAgentRowId)}` : ""
@@ -1910,7 +2029,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=${stringValue(event.jobType || "run")} run=${shortId(event.runId || event.sessionId || event.deployRequestId || event.testRunId)}` };
+      return { ...base, message: `job started type=${stringValue2(event.jobType || "run")} run=${shortId(event.runId || event.sessionId || event.deployRequestId || event.testRunId)}` };
     case "job_completed":
       return {
         ...base,
@@ -1918,18 +2037,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=${stringValue(event.activity)} error=${stringValue(event.error)}` };
+      return { ...base, level: "warn", message: `backend connection lost activity=${stringValue2(event.activity)} error=${stringValue2(event.error)}` };
     case "backend_connection_restored":
-      return { ...base, message: `backend connection restored activity=${stringValue(event.activity)}` };
+      return { ...base, message: `backend connection restored activity=${stringValue2(event.activity)}` };
     case "retry_scheduled":
-      return { ...base, level: "warn", message: `retry scheduled activity=${stringValue(event.activity)} delay=${formatSeconds(event.delaySeconds)}` };
+      return { ...base, level: "warn", message: `retry scheduled activity=${stringValue2(event.activity)} delay=${formatSeconds(event.delaySeconds)}` };
     case "daemon_stderr":
-      return { ...base, level: looksLikeError(event.message || event.stderr) ? "error" : "warn", message: `stderr ${stringValue(event.message || event.stderr)}` };
+      return { ...base, level: looksLikeError(event.message || event.stderr) ? "error" : "warn", message: `stderr ${stringValue2(event.message || event.stderr)}` };
     case "error":
-      return { ...base, level: "error", message: `error scope=${stringValue(event.relativePath || event.path || "daemon")} ${stringValue(event.error || event.code || "unknown")}` };
+      return { ...base, level: "error", message: `error scope=${stringValue2(event.relativePath || event.path || "daemon")} ${stringValue2(event.error || event.code || "unknown")}` };
     case "process_exit":
     case "daemon_exit":
-      return { ...base, level: "error", message: stringValue(event.message || processExitMessage(event)) };
+      return { ...base, level: "error", message: stringValue2(event.message || processExitMessage(event)) };
     case "stopped":
       return { ...base, message: `stopped jobsRun=${Number(event.jobsRun ?? 0)}` };
     default:
@@ -1937,7 +2056,7 @@ function serveDebugEntry(event) {
   }
 }
 function debugLevel(event) {
-  if (event?.level) return stringValue(event.level);
+  if (event?.level) return stringValue2(event.level);
   if (event?.type === "error" || event?.type === "process_exit" || event?.type === "daemon_exit") return "error";
   return "info";
 }
@@ -1945,14 +2064,14 @@ function boolText(value) {
   return value ? "yes" : "no";
 }
 function shortId(value) {
-  const text = stringValue(value);
+  const text = stringValue2(value);
   return text ? text.slice(0, 8) : "unknown";
 }
 function looksLikeError(value) {
-  return /(error|exception|traceback|failed|fatal|denied|unauthorized|timeout)/i.test(stringValue(value));
+  return /(error|exception|traceback|failed|fatal|denied|unauthorized|timeout)/i.test(stringValue2(value));
 }
 function setAgentRunState(agentRunState, relativePath, patch) {
-  const key = stringValue(relativePath || ".");
+  const key = stringValue2(relativePath || ".");
   return {
     ...agentRunState || {},
     [key]: {
@@ -1963,9 +2082,9 @@ function setAgentRunState(agentRunState, relativePath, patch) {
 }
 function failRunningAgents(agentRunState, message, timestamp, relativePath = "") {
   let next = agentRunState || {};
-  for (const [path9, run2] of Object.entries(agentRunState || {})) {
+  for (const [path10, run2] of Object.entries(agentRunState || {})) {
     if (run2?.status !== "running") continue;
-    next = setAgentRunState(next, path9, {
+    next = setAgentRunState(next, path10, {
       status: "error",
       completedAt: timestamp,
       lastEventAt: timestamp,
@@ -1987,40 +2106,40 @@ function appendProcessExitAgentLogs(agentLogs, event, agentRunState, relativePat
   if (relativePath) {
     paths.add(relativePath);
   }
-  for (const [path9, run2] of Object.entries(agentRunState || {})) {
+  for (const [path10, run2] of Object.entries(agentRunState || {})) {
     if (run2?.status === "running") {
-      paths.add(path9);
+      paths.add(path10);
     }
   }
   if (paths.size === 0) {
     return appendAgentLog(agentLogs, event);
   }
   let next = agentLogs || {};
-  for (const path9 of paths) {
-    next = appendAgentLog(next, { ...event, relativePath: path9 });
+  for (const path10 of paths) {
+    next = appendAgentLog(next, { ...event, relativePath: path10 });
   }
   return next;
 }
 function reconcileInventoryRunState(agentRunState, agents, timestamp) {
   let next = agentRunState || {};
   for (const agent of agents || []) {
-    const path9 = stringValue(agent?.relativePath || ".");
-    const current = next[path9];
+    const path10 = stringValue2(agent?.relativePath || ".");
+    const current = next[path10];
     if (agent?.status === "error") {
-      next = setAgentRunState(next, path9, {
+      next = setAgentRunState(next, path10, {
         status: "error",
         lastEventAt: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        errorMessage: stringValue(agent.errorMessage || agent.error || "Agent setup failed")
+        errorMessage: stringValue2(agent.errorMessage || agent.error || "Agent setup failed")
       });
     } else if (agent?.status === "disabled") {
-      next = setAgentRunState(next, path9, {
+      next = setAgentRunState(next, path10, {
         status: "disabled",
         lastEventAt: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        disabledReason: stringValue(agent.disabledReason || "System dependency not met locally"),
+        disabledReason: stringValue2(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) {
-      next = setAgentRunState(next, path9, {
+      next = setAgentRunState(next, path10, {
         status: "ready",
         lastEventAt: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
         progressMessage: null,
@@ -2036,22 +2155,22 @@ function reconcileInventoryRunState(agentRunState, agents, timestamp) {
 function normalizeStoredAgentLogEntry(entry) {
   return {
     timestamp: entry.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    runId: stringValue(entry.runId),
-    eventType: stringValue(entry.eventType || "log"),
-    level: stringValue(entry.level || "info"),
-    message: stringValue(entry.message),
-    stepId: entry.stepId ? stringValue(entry.stepId) : null,
+    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,
     current: entry.current ?? null,
     total: entry.total ?? null,
     success: entry.success ?? null,
     error: entry.error ?? null,
-    jobType: entry.jobType ? stringValue(entry.jobType) : null
+    jobType: entry.jobType ? stringValue2(entry.jobType) : null
   };
 }
 function formatErrorMessage(error) {
   if (!error) return null;
-  if (typeof error === "object") return stringValue(error.message || "error");
-  return stringValue(error);
+  if (typeof error === "object") return stringValue2(error.message || "error");
+  return stringValue2(error);
 }
 function findNewAgents(previous, next) {
   const seen = new Set(previous.map(agentKey).filter(Boolean));
@@ -2064,15 +2183,15 @@ function agentKey(agent) {
   if (!agent || typeof agent !== "object") {
     return "";
   }
-  return stringValue(agent.localAgentId || agent.relativePath || agent.path || agent.manifestName || agent.id);
+  return stringValue2(agent.localAgentId || agent.relativePath || agent.path || agent.manifestName || agent.id);
 }
 function agentLabel(event) {
-  return stringValue(event.relativePath || event.path || ".");
+  return stringValue2(event.relativePath || event.path || ".");
 }
 function jobLabel(event) {
-  return stringValue(event.runId || event.deployRequestId || event.relativePath || event.jobType || "job");
+  return stringValue2(event.runId || event.deployRequestId || event.relativePath || event.jobType || "job");
 }
-function stringValue(value) {
+function stringValue2(value) {
   return value == null ? "" : String(value);
 }
 function processExitMessage(event) {
@@ -2080,59 +2199,28 @@ function processExitMessage(event) {
     return `Agent serve exited with code ${event.code}`;
   }
   if (event?.signal) {
-    return `Agent serve exited from ${event.signal}`;
-  }
-  return "Agent serve exited";
-}
-function agentPrepareLogMessage(event) {
-  if (event.type === "agent_prepare_started") {
-    return "Preparing agent";
-  }
-  if (event.type === "agent_prepare_completed") {
-    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 stringValue(event.message || event.stage || "Preparing agent");
-}
-function textTail(value, limit = 800) {
-  const text = String(value || "").trim().replace(/\s+/g, " ");
-  return text.length > limit ? text.slice(-limit) : text;
-}
-function formatSeconds(value) {
-  const numeric = Number(value);
-  return Number.isFinite(numeric) ? `${numeric.toFixed(1)}s` : "";
-}
-
-// src/serve-process.js
-import { spawn as spawn2 } from "node:child_process";
-async function spawnLocalServeEventStream({
-  agentsDir = "./agents",
-  collectionId = "",
-  env = process.env,
-  platform = process.platform,
-  onProgress = null
-} = {}) {
-  const invocation = await preparePythonVendianInvocation(buildLocalServeEventStreamArgs({ agentsDir, collectionId }), { env, platform, onProgress });
-  return spawn2(invocation.command, invocation.args, {
-    env: invocation.env,
-    stdio: ["ignore", "pipe", "pipe"],
-    shell: false
-  });
-}
-function buildLocalServeEventStreamArgs({ agentsDir = "./agents", collectionId = "" } = {}) {
-  const args = [
-    "cloud",
-    "local",
-    "serve",
-    "--agents-dir",
-    agentsDir || "./agents",
-    "--event-stream"
-  ];
-  if (collectionId) {
-    args.push("--collection-id", collectionId);
+    return `Agent serve exited from ${event.signal}`;
   }
-  return args;
+  return "Agent serve exited";
+}
+function agentPrepareLogMessage(event) {
+  if (event.type === "agent_prepare_started") {
+    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");
+    return "Agent ready";
+  }
+  return stringValue2(event.message || event.stage || "Preparing agent");
+}
+function textTail(value, limit = 800) {
+  const text = String(value || "").trim().replace(/\s+/g, " ");
+  return text.length > limit ? text.slice(-limit) : text;
+}
+function formatSeconds(value) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? `${numeric.toFixed(1)}s` : "";
 }
 
 // src/serve-log-store.js
@@ -2142,12 +2230,12 @@ import path7 from "node:path";
 var MAX_EVENTS = 5e3;
 var MAX_RUNS = 50;
 function createServeLogStore({
-  agentsDir = "./agents",
-  collectionId = "",
+  agentsDir: agentsDir2 = "./agents",
+  collectionId: collectionId2 = "",
   env = process.env,
   platform = process.platform
 } = {}) {
-  const file = serveLogFilePath({ agentsDir, collectionId, env, platform });
+  const file = serveLogFilePath({ agentsDir: agentsDir2, collectionId: collectionId2, env, platform });
   let appendCount = 0;
   return {
     file,
@@ -2162,8 +2250,8 @@ function createServeLogStore({
       fs10.mkdirSync(path7.dirname(file), { recursive: true });
       const record = {
         version: 1,
-        collectionId: collectionId || "",
-        agentsDir: String(agentsDir || "./agents"),
+        collectionId: collectionId2 || "",
+        agentsDir: String(agentsDir2 || "./agents"),
         relativePath: normalized.relativePath,
         entry: normalized.entry
       };
@@ -2181,15 +2269,15 @@ function createServeLogStore({
   };
 }
 function serveLogFilePath({
-  agentsDir = "./agents",
-  collectionId = "",
+  agentsDir: agentsDir2 = "./agents",
+  collectionId: collectionId2 = "",
   env = process.env,
   platform = process.platform
 } = {}) {
   const root = vendianHome(env, platform);
-  const resolvedAgentsDir = path7.resolve(String(agentsDir || "./agents"));
-  const hash = crypto2.createHash("sha256").update(`${collectionId || "default"}\0${resolvedAgentsDir}`).digest("hex").slice(0, 16);
-  return path7.join(root, "serve-logs", `${safePathPart(collectionId || "default")}-${hash}.jsonl`);
+  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`);
 }
 function readServeLogRecords(file) {
   if (!file || !fs10.existsSync(file)) {
@@ -2243,58 +2331,561 @@ function safePathPart(value) {
   return String(value || "default").replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "default";
 }
 
-// src/workspaces.js
-async function listCloudWorkspaces({
+// 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,
-  prepareInvocation = preparePythonVendianInvocation,
-  run: run2 = runCapture,
-  onProgress = null,
-  timeoutMs = 2e4
+  onProgress = null
 } = {}) {
-  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
+  const invocation = await preparePythonVendianInvocation(buildLocalServeEventStreamArgs({ agentsDir: agentsDir2, collectionId: collectionId2 }), { env, platform, onProgress });
+  return spawn2(invocation.command, invocation.args, {
+    env: invocation.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false
   });
-  progress("Loading workspaces from Vendian");
-  const result = run2(invocation.command, invocation.args, { env: invocation.env, timeout: timeoutMs });
-  if (!result.ok) {
+}
+function buildLocalServeEventStreamArgs({ agentsDir: agentsDir2 = "./agents", collectionId: collectionId2 = "" } = {}) {
+  const args = [
+    "cloud",
+    "local",
+    "serve",
+    "--agents-dir",
+    agentsDir2 || "./agents",
+    "--event-stream"
+  ];
+  if (collectionId2) {
+    args.push("--collection-id", collectionId2);
+  }
+  return args;
+}
+
+// src/version.js
+var CLI_VERSION = true ? "0.0.35" : process.env.npm_package_version || "0.0.0-dev";
+
+// src/dev-server.js
+var __dirname = path8.dirname(fileURLToPath(import.meta.url));
+var UI_DIR = fs11.existsSync(path8.join(__dirname, "dev-ui")) ? path8.join(__dirname, "dev-ui") : fs11.existsSync(path8.join(__dirname, "src", "dev-ui")) ? path8.join(__dirname, "src", "dev-ui") : path8.join(__dirname, "dev-ui");
+var serveChild = null;
+var serveState = initialServeState();
+var serveLogs = [];
+var logStore = null;
+var agentsDir = "";
+var collectionId = "";
+async function startDevServer({
+  port = 3859,
+  agents = "",
+  noOpen = false,
+  env = process.env,
+  platform = process.platform
+} = {}) {
+  if (agents) {
+    agentsDir = path8.resolve(agents);
+  } else {
+    const candidates = findAgentDirectoryCandidates();
+    agentsDir = candidates[0]?.absolutePath || path8.resolve("./agents");
+  }
+  const server = http2.createServer(handleRequest);
+  server.listen(port, "127.0.0.1", () => {
+    const url = `http://localhost:${port}`;
+    console.log("");
+    console.log("  \x1B[1;36m\u26A1 Vendian Dev UI\x1B[0m");
+    console.log(`  \x1B[90m${"\u2500".repeat(44)}\x1B[0m`);
+    console.log(`  \x1B[1mLocal:\x1B[0m    ${url}`);
+    console.log(`  \x1B[1mAgents:\x1B[0m   ${agentsDir}`);
+    console.log(`  \x1B[1mVersion:\x1B[0m  ${CLI_VERSION}`);
+    console.log(`  \x1B[90m${"\u2500".repeat(44)}\x1B[0m`);
+    console.log("  \x1B[90mPress Ctrl+C to stop.\x1B[0m");
+    console.log("");
+    if (!noOpen) {
+      setTimeout(() => openUrl(url), 400);
+    }
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`
+  \x1B[31mPort ${port} is already in use.\x1B[0m Try: vendian dev --port ${port + 1}
+`);
+    } else {
+      console.error(`
+  \x1B[31m${err.message}\x1B[0m
+`);
+    }
+    process.exit(1);
+  });
+  process.on("SIGINT", () => shutdown(server));
+  process.on("SIGTERM", () => shutdown(server));
+}
+function shutdown(server) {
+  console.log("\n  \x1B[90mShutting down...\x1B[0m");
+  if (serveChild && !serveChild.killed) {
+    serveChild.kill("SIGTERM");
+  }
+  server.close();
+  process.exit(0);
+}
+function handleRequest(req, res) {
+  const parsed = new URL(req.url, `http://${req.headers.host}`);
+  const pathname = parsed.pathname;
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  if (pathname.startsWith("/api/")) {
+    return handleApi(req, res, pathname, parsed);
+  }
+  serveStatic(req, res, pathname);
+}
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon"
+};
+function serveStatic(req, res, pathname) {
+  let filePath = path8.join(UI_DIR, pathname === "/" ? "index.html" : pathname);
+  if (!fs11.existsSync(filePath) || fs11.statSync(filePath).isDirectory()) {
+    filePath = path8.join(UI_DIR, "index.html");
+  }
+  if (!fs11.existsSync(filePath)) {
+    res.writeHead(404);
+    res.end("Not Found");
+    return;
+  }
+  const ext = path8.extname(filePath);
+  const contentType = MIME_TYPES[ext] || "application/octet-stream";
+  const content = fs11.readFileSync(filePath);
+  res.writeHead(200, { "Content-Type": contentType });
+  res.end(content);
+}
+async function handleApi(req, res, pathname, parsed) {
+  try {
+    if (req.method === "GET") {
+      switch (pathname) {
+        case "/api/status":
+          return apiStatus(req, res);
+        case "/api/agents":
+          return apiAgents(req, res);
+        case "/api/logs":
+          return apiLogs(req, res, parsed);
+        case "/api/serve/state":
+          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);
+      }
+    }
+    if (req.method === "POST") {
+      const body = await readBody(req);
+      switch (pathname) {
+        case "/api/validate":
+          return await apiValidate(req, res, body);
+        case "/api/serve/start":
+          return await apiServeStart(req, res, body);
+        case "/api/serve/stop":
+          return apiServeStop(req, res);
+        case "/api/create":
+          return await apiCreate(req, res, body);
+        case "/api/auth/switch":
+          return await apiAuthSwitch(req, res, body);
+        default:
+          return jsonResponse(res, { error: "not found" }, 404);
+      }
+    }
+    jsonResponse(res, { error: "method not allowed" }, 405);
+  } catch (err) {
+    jsonResponse(res, { error: err.message || "Internal error" }, 500);
+  }
+}
+function apiStatus(req, res) {
+  const serving = serveChild !== null && !serveChild.killed;
+  jsonResponse(res, {
+    serving,
+    agentsDir,
+    collectionId,
+    connected: serveState.connected,
+    activity: serveState.activity,
+    agentCount: serveState.agents.length,
+    jobsRun: serveState.jobsRun,
+    version: CLI_VERSION
+  });
+}
+function apiServeState(req, res) {
+  const serving = serveChild !== null && !serveChild.killed;
+  const agentStatuses = serveState.agents.map((agent) => {
+    const relPath = agent.relativePath || ".";
+    const runtime = agentRuntimeStatus(agent, serveState.agentRunState);
+    const runState = (serveState.agentRunState || {})[relPath] || {};
     return {
-      ok: false,
-      workspaces: [],
-      error: (result.stderr || result.stdout || `workspace list exited with code ${result.status}`).trim()
+      name: agent.manifestName || agent.relativePath || "Agent",
+      relativePath: relPath,
+      status: runtime.status,
+      errorMessage: agent.errorMessage || runState.errorMessage || null,
+      progressMessage: runState.progressMessage || null,
+      lastEventAt: runState.lastEventAt || null,
+      runId: runState.runId || null,
+      jobType: runState.jobType || null
+    };
+  });
+  const activity = [];
+  for (const [agentPath, entries] of Object.entries(serveState.agentLogs || {})) {
+    const agent = serveState.agents.find((a) => (a.relativePath || ".") === agentPath);
+    const name = agent?.manifestName || agentPath;
+    for (const e of (entries || []).slice(-10)) {
+      activity.push({ ...e, _agentName: name, _agentPath: agentPath });
+    }
+  }
+  for (const event of (serveState.logs || []).slice(-30)) {
+    if (!event || !event.type) continue;
+    const ts = event.timestamp || "";
+    const type = event.type;
+    if ([
+      "daemon_registered",
+      "daemon_event_stream_connected",
+      "inventory_synced",
+      "agent_discovery_completed",
+      "backend_connection_lost",
+      "backend_connection_restored",
+      "retry_scheduled",
+      "daemon_event_stream_lost"
+    ].includes(type)) {
+      activity.push({
+        timestamp: ts,
+        eventType: type,
+        level: type.includes("lost") || type.includes("retry") ? "warn" : "info",
+        message: formatDaemonEvent(event),
+        _agentName: "System",
+        _agentPath: ""
+      });
+    }
+  }
+  activity.sort((a, b) => (a.timestamp || "").localeCompare(b.timestamp || ""));
+  jsonResponse(res, {
+    serving,
+    connected: serveState.connected,
+    stopped: serveState.stopped,
+    activity: serveState.activity,
+    agentCount: serveState.agents.length,
+    jobsRun: serveState.jobsRun,
+    agents: agentStatuses,
+    recentActivity: activity.slice(-40),
+    errors: serveState.errors || []
+  });
+}
+function apiAgents(req, res) {
+  const folders = findAgentFolders(agentsDir);
+  const agents = folders.map((folder) => {
+    const manifestPath = path8.join(folder.absolutePath, "manifest.yaml");
+    const info = parseManifestBasic(manifestPath);
+    const relPath = path8.relative(agentsDir, folder.absolutePath).replace(/\\/g, "/") || folder.name;
+    const inventoryAgent = serveState.agents.find(
+      (a) => (a.relativePath || ".") === relPath || a.relativePath === folder.name
+    );
+    const runtime = inventoryAgent ? agentRuntimeStatus(inventoryAgent, serveState.agentRunState) : { status: "unknown" };
+    return {
+      path: folder.absolutePath,
+      relativePath: relPath,
+      name: folder.name,
+      displayName: info.name || folder.name,
+      id: info.id || "",
+      description: info.description || "",
+      version: info.version || "",
+      triggers: info.triggers || [],
+      credentials: info.credentials || [],
+      hasAgentPy: fs11.existsSync(path8.join(folder.absolutePath, "agent.py")),
+      hasRequirements: fs11.existsSync(path8.join(folder.absolutePath, "requirements.txt")),
+      runtimeStatus: runtime.status
+    };
+  });
+  jsonResponse(res, { agents, agentsDir });
+}
+function apiLogs(req, res, parsed) {
+  const since = parseInt(parsed.searchParams.get("since") || "0", 10);
+  const lines = serveLogs.slice(since);
+  jsonResponse(res, { logs: lines, total: serveLogs.length, since });
+}
+function apiAuth(req, res) {
+  const active = activeCloudAuthStatus();
+  const backends = Object.entries(BACKEND_TARGETS).filter(([key]) => !["localhost", "production"].includes(key)).map(([key, url]) => {
+    const status = cloudAuthStatus({ backend: key });
+    return {
+      key,
+      url,
+      authenticated: status.authenticated,
+      email: status.email || null,
+      active: status.apiUrl === active.apiUrl && active.authenticated
     };
+  });
+  jsonResponse(res, {
+    authenticated: active.authenticated,
+    email: active.email || null,
+    apiUrl: active.apiUrl || null,
+    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]) {
+    return jsonResponse(res, { ok: false, error: `Unknown backend: ${backend}` }, 400);
   }
   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}` };
+    const { activateCloudProfile: activateCloudProfile2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    const result = activateCloudProfile2({ backend });
+    if (result?.activated) {
+      jsonResponse(res, { ok: true, switched: true, backend });
+    } else {
+      jsonResponse(res, { ok: false, needsLogin: true, backend, url: BACKEND_TARGETS[backend] });
+    }
+  } catch (err) {
+    jsonResponse(res, { ok: false, error: err.message });
   }
 }
-function normalizeWorkspaceList(payload) {
-  const data = payload && typeof payload === "object" && "data" in payload ? payload.data : payload;
-  const raw = Array.isArray(data) ? data : data && typeof data === "object" && Array.isArray(data.data) ? data.data : data && typeof data === "object" && Array.isArray(data.collections) ? data.collections : [];
-  return raw.filter((item) => item && typeof item === "object").map((item) => ({
-    id: stringValue2(item.id),
-    name: stringValue2(item.name || item.slug || item.id || "Unnamed workspace"),
-    slug: stringValue2(item.slug)
-  })).filter((item) => item.id);
+async function apiValidate(req, res, body) {
+  const targetPath = body.path || agentsDir;
+  const invocation = await preparePythonVendianInvocation(
+    ["validate", targetPath, "--json", "--no-runtime"],
+    { skipAutoUpdate: true }
+  );
+  const result = await runCaptureAsync(invocation.command, invocation.args, { env: invocation.env });
+  try {
+    const parsed = JSON.parse(result.stdout);
+    jsonResponse(res, parsed);
+  } catch {
+    jsonResponse(res, {
+      valid: false,
+      errors: result.stderr ? [result.stderr.trim()] : ["Validation failed"],
+      stdout: result.stdout
+    });
+  }
 }
-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}`;
+async function apiServeStart(req, res, body) {
+  if (serveChild && !serveChild.killed) {
+    return jsonResponse(res, { ok: false, error: "Already serving" });
+  }
+  const targetDir = body.agentsDir || agentsDir;
+  const targetCollection = body.collectionId || collectionId;
+  try {
+    const invocation = await preparePythonVendianInvocation(
+      buildLocalServeEventStreamArgs({ agentsDir: targetDir, collectionId: targetCollection }),
+      { onProgress: null }
+    );
+    serveState = initialServeState();
+    serveLogs = [];
+    logStore = createServeLogStore({ agentsDir: targetDir, collectionId: targetCollection });
+    serveChild = spawn3(invocation.command, invocation.args, {
+      env: invocation.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+    let buffer = "";
+    serveChild.stdout.setEncoding("utf8");
+    serveChild.stdout.on("data", (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        serveLogs.push(line);
+        if (serveLogs.length > 5e3) serveLogs.shift();
+        try {
+          const event = parseServeEventLine(line);
+          if (event) {
+            serveState = applyServeEvent(serveState, event);
+            try {
+              logStore?.append(event);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    serveChild.stderr.setEncoding("utf8");
+    serveChild.stderr.on("data", (chunk) => {
+      const text = chunk.trim();
+      if (text) {
+        serveLogs.push(`[stderr] ${text}`);
+        if (serveLogs.length > 5e3) serveLogs.shift();
+      }
+    });
+    serveChild.on("exit", (code, signal) => {
+      serveState = { ...serveState, stopped: true, connected: false };
+      serveLogs.push(`[process] Exited code=${code} signal=${signal || "none"}`);
+      serveChild = null;
+      try {
+        logStore?.compact();
+      } catch {
+      }
+    });
+    jsonResponse(res, { ok: true, pid: serveChild.pid });
+  } catch (err) {
+    jsonResponse(res, { ok: false, error: err.message });
+  }
 }
-function stringValue2(value) {
-  return value == null ? "" : String(value).trim();
+function apiServeStop(req, res) {
+  if (!serveChild || serveChild.killed) {
+    return jsonResponse(res, { ok: true, wasRunning: false });
+  }
+  serveChild.kill("SIGTERM");
+  setTimeout(() => {
+    if (serveChild && !serveChild.killed) {
+      serveChild.kill("SIGKILL");
+    }
+  }, 3e3);
+  jsonResponse(res, { ok: true, wasRunning: true });
+}
+async function apiCreate(req, res, body) {
+  const name = (body.name || "").trim();
+  if (!name) {
+    return jsonResponse(res, { ok: false, error: "Name is required" }, 400);
+  }
+  try {
+    const invocation = await preparePythonVendianInvocation(
+      ["create", name, "--output-dir", agentsDir],
+      { skipAutoUpdate: true }
+    );
+    const result = await runCaptureAsync(invocation.command, invocation.args, { env: invocation.env });
+    if (result.code === 0) {
+      jsonResponse(res, { ok: true, name, output: result.stdout });
+    } else {
+      jsonResponse(res, { ok: false, error: result.stderr || result.stdout || "Create failed" });
+    }
+  } catch (err) {
+    jsonResponse(res, { ok: false, error: err.message });
+  }
+}
+function jsonResponse(res, data, status = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(body);
+}
+function readBody(req) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        resolve({});
+      }
+    });
+  });
+}
+function runCaptureAsync(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn3(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      ...options
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d;
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    child.on("exit", (code) => {
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+    child.on("error", (err) => {
+      resolve({ code: 1, stdout, stderr: err.message });
+    });
+  });
+}
+function parseManifestBasic(manifestPath) {
+  try {
+    const content = fs11.readFileSync(manifestPath, "utf8");
+    const get = (key) => {
+      const m = content.match(new RegExp(`^${key}\\s*:\\s*['"]?([^'"\\n#]+?)['"]?\\s*$`, "m"));
+      return m ? m[1].trim() : "";
+    };
+    const getList = (key) => {
+      const m = content.match(new RegExp(`^${key}\\s*:`, "m"));
+      if (!m) return [];
+      const after = content.slice(m.index + m[0].length);
+      const lines = after.split("\n");
+      const items = [];
+      for (const line of lines) {
+        if (/^\s+-\s/.test(line) || /^\s+\w+\s*:/.test(line)) {
+          const val = line.replace(/^\s+[-]?\s*/, "").replace(/:.*$/, "").trim();
+          if (val) items.push(val);
+        } else if (/^\S/.test(line) && items.length > 0) {
+          break;
+        }
+      }
+      return items;
+    };
+    return {
+      id: get("id"),
+      name: get("name"),
+      description: get("description"),
+      version: get("version"),
+      triggers: getList("triggers"),
+      credentials: getList("credentials")
+    };
+  } catch {
+    return {};
+  }
+}
+function formatDaemonEvent(event) {
+  switch (event.type) {
+    case "daemon_registered":
+      return "Connected to backend";
+    case "daemon_event_stream_connected":
+      return "Event stream connected";
+    case "daemon_event_stream_lost":
+      return `Event stream lost: ${event.error || "unknown"}`;
+    case "inventory_synced":
+      return `Inventory synced (${event.agentCount || 0} agents)`;
+    case "agent_discovery_completed":
+      return `Discovered ${event.agentCount || 0} agents`;
+    case "backend_connection_lost":
+      return `Connection lost: ${event.error || event.activity || "unknown"}`;
+    case "backend_connection_restored":
+      return "Connection restored";
+    case "retry_scheduled":
+      return `Retrying ${event.activity || "operation"} in ${event.delaySeconds || "?"}s`;
+    default:
+      return event.type;
+  }
+}
+function openUrl(url) {
+  const cmd = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const shell = process.platform === "win32" ? "cmd.exe" : void 0;
+  spawn3(shell || cmd, shell ? args : [url], { detached: true, stdio: "ignore" }).unref();
 }
 
+// src/tui.js
+init_constants();
+init_auth();
+import { spawnSync as spawnSync4 } from "node:child_process";
+import fs12 from "node:fs";
+import path9 from "node:path";
+import readline from "node:readline";
+
+// src/npm-update.js
+var NPM_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
+
 // src/ui/figures.js
 var supportsUnicode = process.platform !== "win32" || Boolean(
   process.env.WT_SESSION || // Windows Terminal
@@ -2602,10 +3193,16 @@ var COMMAND_GROUPS = [
     { cmd: "vendian models", desc: "List available AI models" }
   ] },
   { 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" }
+  ] },
   { section: "Maintenance", commands: [
     { cmd: "vendian doctor", desc: "Check if everything is set up" },
     { cmd: "vendian update", desc: "Update to the latest version" }
@@ -2649,7 +3246,7 @@ async function pickProject({ env, platform, candidates }) {
   print(col.bold("  Which project do you want to run?"));
   print("");
   const items = candidates.map((candidate) => {
-    const name = readManifestName(candidate.absolutePath) || friendlyName(path8.basename(candidate.absolutePath) || candidate.path);
+    const name = readManifestName(candidate.absolutePath) || friendlyName(path9.basename(candidate.absolutePath) || candidate.path);
     return `${name.padEnd(32)}  ${col.gray(`${candidate.agentCount} agent${candidate.agentCount === 1 ? "" : "s"}`)}`;
   });
   const idx = await pickMenu(items, { allowBack: true });
@@ -2663,7 +3260,7 @@ async function pickAgentsFromFolder({ env, platform, candidate }) {
   if (folders.length <= 1) return { agentsDir: candidate.path };
   const named = folders.map((f) => ({
     ...f,
-    displayName: readManifestName(f.absolutePath) || friendlyName(f.name || path8.basename(f.path))
+    displayName: readManifestName(f.absolutePath) || friendlyName(f.name || path9.basename(f.path))
   }));
   clearScreen();
   printHeader({ env, platform });
@@ -2686,19 +3283,19 @@ async function pickSingleAgentToRun({ env, platform, candidates }) {
     print(col.yellow("  Couldn't find any agents."));
     const input = await ask("Agent folder", "./agents/my-agent");
     if (!input) return null;
-    return { path: input, displayName: friendlyName(path8.basename(input) || "Agent") };
+    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 || path8.basename(folder.path))
+        displayName: readManifestName(folder.absolutePath) || friendlyName(folder.name || path9.basename(folder.path))
       }));
     }
     return [{
       path: candidate.path,
-      displayName: readManifestName(candidate.absolutePath) || friendlyName(path8.basename(candidate.absolutePath) || candidate.path)
+      displayName: readManifestName(candidate.absolutePath) || friendlyName(path9.basename(candidate.absolutePath) || candidate.path)
     }];
   });
   if (agents.length === 1) return agents[0];
@@ -2798,7 +3395,7 @@ async function showServe({ env, platform }) {
   const candidates = findAgentDirectoryCandidates();
   const picked = await pickAgentsToRun({ env, platform, candidates });
   if (!picked) return "home";
-  const { agentsDir } = picked;
+  const { agentsDir: agentsDir2 } = picked;
   const workspace = await chooseCloudWorkspace({
     env,
     platform,
@@ -2806,9 +3403,9 @@ async function showServe({ env, platform }) {
     pickerTitle: "Which project do you want to run?"
   });
   if (!workspace) return "home";
-  return await runServeDashboard({ env, platform, agentsDir, collectionId: workspace.id, wsLabel: workspace.label });
+  return await runServeDashboard({ env, platform, agentsDir: agentsDir2, collectionId: workspace.id, wsLabel: workspace.label });
 }
-async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLabel = "" }) {
+async function runServeDashboard({ env, platform, agentsDir: agentsDir2, collectionId: collectionId2, wsLabel = "" }) {
   let state = initialServeState();
   let child = null;
   let ctrlCArmed = false;
@@ -2817,7 +3414,7 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
   let stopSignalAttempt = 0;
   let stopTimer = null;
   let dashboardClosed = false;
-  let logStore = null;
+  let logStore2 = null;
   let lastAgentOnlinePrint = 0;
   let agentsSeenOnline = false;
   let initialSetupDone = false;
@@ -2827,8 +3424,8 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
   print("");
   print(col.gray("\u2550".repeat(W)));
   print(`  ${col.cyan(col.bold("\u2191 VENDIAN"))}  ${col.bold("Serving agents")}`);
-  print(`  ${col.gray("Dir:")}       ${agentsDir}`);
-  print(`  ${col.gray("Workspace:")} ${wsLabel || collectionId || "\u2014"}`);
+  print(`  ${col.gray("Dir:")}       ${agentsDir2}`);
+  print(`  ${col.gray("Workspace:")} ${wsLabel || collectionId2 || "\u2014"}`);
   print(col.gray(hr(W)));
   print(col.gray("  S stop gracefully  |  ^c ^c exit"));
   print(col.gray(hr(W)));
@@ -2855,7 +3452,7 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
     if (!event) return;
     const type = String(event.type || "");
     const agentPath = String(event.relativePath || event.path || "");
-    const agentName = agentPath ? friendlyName(path8.basename(agentPath)) || agentPath : ".";
+    const agentName = agentPath ? friendlyName(path9.basename(agentPath)) || agentPath : ".";
     if (type === "daemon_wake_received") return;
     if (type === "lease_claim_no_job") return;
     if (type === "dispatch_job_received" || type === "dispatch_job_acked") return;
@@ -2866,7 +3463,7 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
       const now = Date.now();
       if (!hasProblems && allOnline && agentsSeenOnline && now - lastAgentOnlinePrint < 12e4) return;
       for (const a of agents) {
-        const name = friendlyName(path8.basename(a.relativePath || ".")) || a.manifestName || a.relativePath || "?";
+        const name = friendlyName(path9.basename(a.relativePath || ".")) || a.manifestName || a.relativePath || "?";
         if (a.status === "error") {
           printAgent(name, col.red(`\u2716 Error: ${a.errorMessage || ""}`));
           continue;
@@ -2945,15 +3542,15 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
     }
   }
   try {
-    logStore = createServeLogStore({ agentsDir, collectionId, env, platform });
-    const historicalLogs = logStore.load();
+    logStore2 = createServeLogStore({ agentsDir: agentsDir2, collectionId: collectionId2, env, platform });
+    const historicalLogs = logStore2.load();
     if (historicalLogs.length > 0) {
       const agentLogs = mergeAgentLogRecords(state.agentLogs, historicalLogs);
       state = { ...state, agentLogs, agentRunState: { ...agentRunStateFromLogs(agentLogs, { includeRunning: false }), ...state.agentRunState } };
     }
     child = await spawnLocalServeEventStream({
-      agentsDir,
-      collectionId,
+      agentsDir: agentsDir2,
+      collectionId: collectionId2,
       env,
       platform,
       onProgress: (msg) => {
@@ -2962,7 +3559,7 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
       }
     });
     process.stdout.write("\r" + " ".repeat(80) + "\r");
-    printDaemon("serve_started", col.gray(`dir=${agentsDir}`));
+    printDaemon("serve_started", col.gray(`dir=${agentsDir2}`));
   } catch (error) {
     setCursorVisible(true);
     print(col.red(`  ${fig.cross} Failed to start: ${errMsg(error)}`));
@@ -2991,9 +3588,13 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
         if (!stopRequested || dashboardClosed || !childIsRunning()) return;
         stopSignalAttempt += 1;
         const signal = stopSignalForAttempt(stopSignalAttempt);
-        try {
-          child.kill(signal);
-        } catch {
+        if (process.platform === "win32") {
+          killProcessTree(child);
+        } else {
+          try {
+            child.kill(signal);
+          } catch {
+          }
         }
         if (signal !== "SIGKILL") scheduleStopEscalation();
       }, 4e3);
@@ -3009,18 +3610,25 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
       print(col.yellow("\n  Stopping your agents\u2026"));
       clearTimeout(ctrlCArmTimer);
       ctrlCArmed = false;
-      try {
-        child.kill(stopSignalForAttempt(stopSignalAttempt));
-      } catch {
+      if (process.platform === "win32") {
+        killProcessTree(child);
+      } else {
+        try {
+          child.kill(stopSignalForAttempt(stopSignalAttempt));
+        } catch {
+        }
+        scheduleStopEscalation();
       }
-      scheduleStopEscalation();
     }
     if (process.stdin.isTTY) {
       let onKeypress = function(str, key) {
         if (!key) return;
         if (key.ctrl && key.name === "c") {
           if (ctrlCArmed) {
-            child?.kill("SIGINT");
+            try {
+              child?.kill("SIGINT");
+            } catch (error) {
+            }
             finish("exit");
             return;
           }
@@ -3060,7 +3668,7 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
           const event = parseServeEventLine(line);
           if (event) {
             try {
-              logStore?.append(event);
+              logStore2?.append(event);
             } catch {
             }
             state = applyServeEvent(state, event);
@@ -3102,7 +3710,7 @@ async function runServeDashboard({ env, platform, agentsDir, collectionId, wsLab
         print(col.gray("\n  Agents stopped."));
       }
       try {
-        logStore?.compact();
+        logStore2?.compact();
       } catch {
       }
       removeKeypress();
@@ -3238,7 +3846,7 @@ function endpointErrorStatus(error) {
 }
 function buildLocalRunArgs({
   agentPath = ".",
-  collectionId = "",
+  collectionId: collectionId2 = "",
   inputJson = "{}"
 } = {}) {
   return [
@@ -3246,7 +3854,7 @@ function buildLocalRunArgs({
     "local",
     "run",
     "--collection-id",
-    collectionId,
+    collectionId2,
     "--path",
     agentPath || ".",
     "--input-json",
@@ -3258,31 +3866,51 @@ function stopSignalForAttempt(attempt = 0) {
   if (attempt === 1) return "SIGTERM";
   return "SIGKILL";
 }
+function killProcessTree(child) {
+  if (!child || child.exitCode != null || child.signalCode != null) return;
+  if (process.platform === "win32") {
+    try {
+      spawnSync4("taskkill", ["/F", "/T", "/PID", String(child.pid)], { stdio: "ignore" });
+    } catch {
+    }
+  } else {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  }
+}
 function helpText() {
   return [
     "",
     `  \u2191 VENDIAN CLI v${CLI_VERSION}`,
     "",
     "  Usage:",
-    "    vendian                       Open the interactive shell",
+    "    vendian                       Open the dev UI in your browser",
+    "    vendian terminal              Open the interactive terminal shell",
     "    vendian login                 Sign in and prepare the local runtime",
     "    vendian doctor                Check local bootstrap health",
     "    vendian update                Update the managed runtime",
     "    vendian init                  Write SDK agent docs into a workspace",
     '    vendian create "My Agent"     Scaffold a new agent from templates',
+    "    vendian dev                   Open the dev UI (alias for bare vendian)",
     "    vendian <command>             Run a managed Python SDK/cloud command",
     "",
     "  Examples:",
+    "    vendian",
+    "    vendian terminal",
     "    vendian login",
     "    vendian init --output-dir ./agents",
     '    vendian create "My Agent" --output-dir ./agents',
     "    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 doctor",
     "    vendian update",
     "",
-    `  Run \u203A vendian \u203A to open the interactive shell`,
+    `  Run \u203A vendian terminal \u203A for the interactive terminal shell`,
     ""
   ].join("\n");
 }
@@ -3293,7 +3921,7 @@ function readManifestName(absoluteFolderPath) {
   if (!absoluteFolderPath) return null;
   for (const fname of ["manifest.yaml", "manifest.yml"]) {
     try {
-      const content = fs11.readFileSync(path8.join(absoluteFolderPath, fname), "utf8");
+      const content = fs12.readFileSync(path9.join(absoluteFolderPath, fname), "utf8");
       const m = content.match(/^name\s*:\s*['"]?([^'"\n#]+?)['"]?\s*$/m);
       if (m?.[1]) return m[1].trim();
     } catch {
@@ -3341,11 +3969,7 @@ Environment:
 async function main(argv) {
   const [command, ...rest] = argv;
   if (!command) {
-    if (process.stdin.isTTY && process.stdout.isTTY) {
-      await runTui();
-    } else {
-      printHelp();
-    }
+    await startDevServer(parseDevOptions([]));
     return;
   }
   if (command === "--help" || command === "-h") {
@@ -3356,10 +3980,22 @@ async function main(argv) {
     console.log(CLI_VERSION);
     return;
   }
+  if (command === "terminal" || command === "tui") {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      await runTui();
+    } else {
+      printHelp();
+    }
+    return;
+  }
   if (isBootstrapCommand(command)) {
     await setup(parseSetupOptions(rest));
     return;
   }
+  if (command === "dev") {
+    await startDevServer(parseDevOptions(rest));
+    return;
+  }
   if (command === "doctor") {
     doctor();
     return;
@@ -3368,11 +4004,33 @@ async function main(argv) {
     await setup({ nonInteractive: true });
     return;
   }
+  if (command.startsWith("--port") || command.startsWith("-p") || command === "--no-open" || command === "--agents-dir" || command === "--agents") {
+    await startDevServer(parseDevOptions(argv));
+    return;
+  }
   await forwardToPythonVendian(argv);
 }
 function isBootstrapCommand(command) {
   return command === "login" || command === "setup";
 }
+function parseDevOptions(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" || arg === "-p") {
+      options.port = parseInt(args[++i], 10) || 3859;
+    } else if (arg.startsWith("--port=")) {
+      options.port = parseInt(arg.slice(7), 10) || 3859;
+    } else if (arg === "--agents-dir" || arg === "--agents") {
+      options.agents = args[++i];
+    } else if (arg.startsWith("--agents-dir=")) {
+      options.agents = arg.slice(13);
+    } else if (arg === "--no-open") {
+      options.noOpen = true;
+    }
+  }
+  return options;
+}
 function parseSetupOptions(args) {
   const options = {
     nonInteractive: args.includes("--yes") || args.includes("--non-interactive"),