@recursiv/cli 0.1.5

package/dist/bin/recursiv.js

@@ -0,0 +1,4172 @@
+#!/usr/bin/env node
+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/lib/logger.ts
+import pc from "picocolors";
+function banner() {
+  console.log();
+  console.log(pc.bold("Recursiv") + pc.dim(" \u2014 build and ship apps with AI"));
+  console.log();
+}
+var log;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    "use strict";
+    log = {
+      info(msg) {
+        console.log(pc.cyan("info") + "  " + msg);
+      },
+      success(msg) {
+        console.log(pc.green("ok") + "    " + msg);
+      },
+      warn(msg) {
+        console.log(pc.yellow("warn") + "  " + msg);
+      },
+      error(msg) {
+        console.error(pc.red("error") + " " + msg);
+      },
+      step(n, total, msg) {
+        console.log(pc.dim(`[${n}/${total}]`) + " " + msg);
+      },
+      blank() {
+        console.log();
+      }
+    };
+  }
+});
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  configPath: () => configPath,
+  createConfig: () => createConfig,
+  readConfig: () => readConfig,
+  writeConfig: () => writeConfig
+});
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+function configPath(dir) {
+  return join(dir, CONFIG_FILE);
+}
+async function readConfig(dir) {
+  try {
+    const raw = await readFile(configPath(dir), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeConfig(dir, config) {
+  await writeFile(configPath(dir), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function createConfig(opts) {
+  return {
+    version: 1,
+    project: {
+      name: opts.name,
+      template: opts.template,
+      framework: opts.framework
+    },
+    api: {
+      baseUrl: "https://api.recursiv.io/api/v1"
+    },
+    dev: {
+      port: opts.port ?? 3e3,
+      command: opts.devCommand ?? "npm run dev"
+    }
+  };
+}
+var CONFIG_FILE;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    CONFIG_FILE = ".recursiv.json";
+  }
+});
+
+// src/lib/env.ts
+var env_exports = {};
+__export(env_exports, {
+  readApiKeyFromEnv: () => readApiKeyFromEnv,
+  updateApiKeyInEnv: () => updateApiKeyInEnv,
+  writeEnvFile: () => writeEnvFile
+});
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function writeEnvFile(dir, apiKey) {
+  const envPath = join2(dir, ".env");
+  const content = [
+    "# Recursiv API key",
+    `RECURSIV_API_KEY=${apiKey}`,
+    "",
+    "# Framework-specific public keys (uncomment as needed)",
+    `# NEXT_PUBLIC_RECURSIV_API_KEY=${apiKey}`,
+    `# VITE_RECURSIV_API_KEY=${apiKey}`,
+    ""
+  ].join("\n");
+  await writeFile2(envPath, content, "utf-8");
+}
+async function readApiKeyFromEnv(dir) {
+  try {
+    const raw = await readFile2(join2(dir, ".env"), "utf-8");
+    const match = raw.match(/^RECURSIV_API_KEY=(.+)$/m);
+    return match?.[1]?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+async function updateApiKeyInEnv(dir, apiKey) {
+  const envPath = join2(dir, ".env");
+  let content;
+  try {
+    content = await readFile2(envPath, "utf-8");
+    if (content.includes("RECURSIV_API_KEY=")) {
+      content = content.replace(/^RECURSIV_API_KEY=.+$/m, `RECURSIV_API_KEY=${apiKey}`);
+    } else {
+      content += `
+RECURSIV_API_KEY=${apiKey}
+`;
+    }
+  } catch {
+    content = `RECURSIV_API_KEY=${apiKey}
+`;
+  }
+  await writeFile2(envPath, content, "utf-8");
+}
+var init_env = __esm({
+  "src/lib/env.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/auth-flow.ts
+var auth_flow_exports = {};
+__export(auth_flow_exports, {
+  getOrCreateApiKey: () => getOrCreateApiKey,
+  isValidKeyFormat: () => isValidKeyFormat,
+  promptAndValidateApiKey: () => promptAndValidateApiKey,
+  promptApiKey: () => promptApiKey,
+  terminalSignup: () => terminalSignup,
+  validateApiKey: () => validateApiKey
+});
+import prompts from "prompts";
+import pc2 from "picocolors";
+function isValidKeyFormat(key) {
+  return API_KEY_PATTERN.test(key);
+}
+async function validateApiKey(apiKey, baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl}/users/me`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      }
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function terminalSignup(baseUrl) {
+  const rootUrl = baseUrl.replace(/\/api\/v1\/?$/, "");
+  console.log();
+  console.log(pc2.bold("Create a free Recursiv account"));
+  console.log(pc2.dim("Free tier: 1,000 API calls/day, 1 agent, 3 projects"));
+  console.log(pc2.dim("We'll send a 6-digit code to your email \u2014 no password needed."));
+  console.log();
+  const { email } = await prompts(
+    {
+      type: "text",
+      name: "email",
+      message: "Email",
+      validate: (v) => {
+        if (!v || !v.includes("@")) return "Valid email required";
+        return true;
+      }
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  const origin = rootUrl || "https://api.recursiv.io";
+  const authHeaders = { "Content-Type": "application/json", Origin: origin };
+  try {
+    const sendRes = await fetch(`${rootUrl}/api/auth/email-otp/send-verification-otp`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify({ email, type: "sign-in" })
+    });
+    if (!sendRes.ok) {
+      const errBody = await sendRes.text().catch(() => "");
+      log.error(`Failed to send code (${sendRes.status}): ${errBody || "Unknown error"}`);
+      return null;
+    }
+  } catch (err) {
+    log.error(
+      `Could not reach ${rootUrl} \u2014 ${err instanceof Error ? err.message : "network error"}`
+    );
+    log.info(`You can create an API key manually at ${pc2.underline(DASHBOARD_URL)}`);
+    return null;
+  }
+  log.success(`Verification code sent to ${email}`);
+  console.log();
+  const { code } = await prompts(
+    {
+      type: "text",
+      name: "code",
+      message: "Enter the 6-digit code",
+      validate: (v) => {
+        if (!v || !/^\d{6}$/.test(v.trim())) return "Enter the 6-digit code from your email";
+        return true;
+      }
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  let sessionCookie = null;
+  try {
+    const verifyRes = await fetch(`${rootUrl}/api/auth/email-otp/verify-email`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify({ email, otp: code.trim() }),
+      redirect: "manual"
+    });
+    if (verifyRes.ok || verifyRes.status === 302) {
+      sessionCookie = extractSessionCookie(verifyRes);
+    } else {
+      const errBody = await verifyRes.text().catch(() => "");
+      log.error(`Verification failed (${verifyRes.status}): ${errBody || "Invalid or expired code"}`);
+      return null;
+    }
+  } catch (err) {
+    log.error(
+      `Verification failed \u2014 ${err instanceof Error ? err.message : "network error"}`
+    );
+    return null;
+  }
+  if (!sessionCookie) {
+    log.error("No session returned from server");
+    log.info(`Create an API key manually at ${pc2.underline(DASHBOARD_URL)}`);
+    return null;
+  }
+  log.success("Authenticated");
+  try {
+    const keyRes = await fetch(`${baseUrl}/api-keys`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Cookie: sessionCookie
+      },
+      body: JSON.stringify({
+        name: "CLI (auto-created)",
+        scopes: DEFAULT_SCOPES
+      })
+    });
+    if (!keyRes.ok) {
+      const errBody = await keyRes.text().catch(() => "");
+      log.error(`Failed to create API key (${keyRes.status}): ${errBody}`);
+      log.info(`Create one manually at ${pc2.underline(DASHBOARD_URL)}`);
+      return null;
+    }
+    const { data } = await keyRes.json();
+    log.success(`API key created (free tier: 1,000 calls/day)`);
+    return data.key;
+  } catch (err) {
+    log.error(
+      `Failed to create API key: ${err instanceof Error ? err.message : "unknown error"}`
+    );
+    log.info(`Create one manually at ${pc2.underline(DASHBOARD_URL)}`);
+    return null;
+  }
+}
+function extractSessionCookie(res) {
+  const setCookieHeaders = "getSetCookie" in res.headers ? res.headers.getSetCookie() : [];
+  if (setCookieHeaders.length === 0) {
+    const raw = res.headers.get("set-cookie");
+    if (raw) {
+      return raw.split(",").map((c) => c.split(";")[0].trim()).join("; ");
+    }
+    return null;
+  }
+  return setCookieHeaders.map((c) => c.split(";")[0].trim()).join("; ");
+}
+async function promptApiKey() {
+  console.log(
+    pc2.dim(
+      `Get your API key from ${pc2.underline(DASHBOARD_URL)}
+Keys start with sk_live_ or sk_test_`
+    )
+  );
+  console.log();
+  const { apiKey } = await prompts(
+    {
+      type: "text",
+      name: "apiKey",
+      message: "API key (or press Enter to skip)",
+      validate: (value) => {
+        if (!value) return true;
+        if (!isValidKeyFormat(value)) {
+          return "Invalid key format. Keys start with sk_live_ or sk_test_";
+        }
+        return true;
+      }
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  if (!apiKey) {
+    log.warn("No API key provided \u2014 you can add one later in .env");
+    return null;
+  }
+  return apiKey;
+}
+async function promptAndValidateApiKey(baseUrl) {
+  const apiKey = await promptApiKey();
+  if (!apiKey) return null;
+  const valid = await validateApiKey(apiKey, baseUrl);
+  if (!valid) {
+    log.warn("Could not validate API key (server unreachable or invalid key)");
+    log.info("Key saved to .env \u2014 you can update it later");
+  } else {
+    log.success("API key validated");
+  }
+  return apiKey;
+}
+async function getOrCreateApiKey(baseUrl) {
+  console.log();
+  const { method } = await prompts(
+    {
+      type: "select",
+      name: "method",
+      message: "How would you like to authenticate?",
+      choices: [
+        {
+          title: "Create a free account",
+          description: "Sign up with email (we'll send a 6-digit code)",
+          value: "signup"
+        },
+        {
+          title: "Enter an existing API key",
+          description: "Paste a key from your dashboard",
+          value: "paste"
+        },
+        {
+          title: "Skip for now",
+          description: "Add an API key later in .env",
+          value: "skip"
+        }
+      ]
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  if (method === "signup") {
+    return terminalSignup(baseUrl);
+  }
+  if (method === "paste") {
+    return promptAndValidateApiKey(baseUrl);
+  }
+  log.warn("No API key \u2014 you can add one later in .env");
+  return null;
+}
+var API_KEY_PATTERN, DASHBOARD_URL, DEFAULT_SCOPES;
+var init_auth_flow = __esm({
+  "src/lib/auth-flow.ts"() {
+    "use strict";
+    init_logger();
+    API_KEY_PATTERN = /^sk_(live|test)_[a-zA-Z0-9]{20,}$/;
+    DASHBOARD_URL = "https://recursiv.io/dashboard/api-keys";
+    DEFAULT_SCOPES = [
+      "posts:read",
+      "posts:write",
+      "chat:read",
+      "chat:write",
+      "agents:read",
+      "agents:write",
+      "projects:read",
+      "projects:write",
+      "communities:read",
+      "communities:write",
+      "users:read"
+    ];
+  }
+});
+
+// src/lib/credentials.ts
+var credentials_exports = {};
+__export(credentials_exports, {
+  readCredentials: () => readCredentials,
+  resolveAnthropicKey: () => resolveAnthropicKey,
+  resolveRecursivKey: () => resolveRecursivKey,
+  saveCredentials: () => saveCredentials
+});
+import { readFile as readFile4, writeFile as writeFile5, mkdir as mkdir2 } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir } from "os";
+async function readCredentials() {
+  try {
+    const raw = await readFile4(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveCredentials(creds) {
+  await mkdir2(RECURSIV_DIR, { recursive: true });
+  const existing = await readCredentials();
+  const merged = { ...existing, ...creds };
+  await writeFile5(CREDENTIALS_PATH, JSON.stringify(merged, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+    // Owner-only read/write
+  });
+}
+async function resolveRecursivKey(projectDir) {
+  const envKey = process.env.RECURSIV_API_KEY || process.env.SOCIAL_DEV_API_KEY;
+  if (envKey) return envKey;
+  if (projectDir) {
+    try {
+      const { readApiKeyFromEnv: readApiKeyFromEnv2 } = await Promise.resolve().then(() => (init_env(), env_exports));
+      const projKey = await readApiKeyFromEnv2(projectDir);
+      if (projKey) return projKey;
+    } catch {
+    }
+  }
+  const creds = await readCredentials();
+  return creds.recursivApiKey || null;
+}
+async function resolveAnthropicKey() {
+  if (process.env.ANTHROPIC_API_KEY) return process.env.ANTHROPIC_API_KEY;
+  const creds = await readCredentials();
+  return creds.anthropicApiKey || null;
+}
+var RECURSIV_DIR, CREDENTIALS_PATH;
+var init_credentials = __esm({
+  "src/lib/credentials.ts"() {
+    "use strict";
+    RECURSIV_DIR = join4(homedir(), ".recursiv");
+    CREDENTIALS_PATH = join4(RECURSIV_DIR, "credentials");
+  }
+});
+
+// src/commands/mcp-install.ts
+var mcp_install_exports = {};
+__export(mcp_install_exports, {
+  mcpInstallCommand: () => mcpInstallCommand,
+  mcpVerifyCommand: () => mcpVerifyCommand
+});
+import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir3 } from "fs/promises";
+import { join as join5, resolve as resolve3 } from "path";
+import { homedir as homedir2, platform } from "os";
+import pc11 from "picocolors";
+async function mcpInstallCommand(opts) {
+  const target = opts.target;
+  if (!VALID_TARGETS.includes(target)) {
+    console.error(
+      pc11.red("error") + ` Unknown target "${opts.target}". Valid targets: ${VALID_TARGETS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const { resolveRecursivKey: resolveRecursivKey2, saveCredentials: saveCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  let apiKey = opts.apiKey || await resolveRecursivKey2(process.cwd());
+  if (!apiKey) {
+    console.log();
+    console.log(pc11.dim("  No Recursiv API key found. Let's authenticate."));
+    console.log();
+    const { getOrCreateApiKey: getOrCreateApiKey2 } = await Promise.resolve().then(() => (init_auth_flow(), auth_flow_exports));
+    const baseUrl = process.env.RECURSIV_BASE_URL || "https://api.recursiv.io/api/v1";
+    apiKey = await getOrCreateApiKey2(baseUrl);
+    if (!apiKey) {
+      console.error(pc11.red("  error") + " Authentication required to continue.");
+      process.exit(1);
+    }
+    await saveCredentials2({ recursivApiKey: apiKey });
+    console.log(pc11.dim("  Credentials saved to ~/.recursiv/credentials"));
+    console.log();
+  }
+  switch (target) {
+    case "claude-code":
+      await installClaudeCode(apiKey, opts.global);
+      break;
+    case "claude-desktop":
+      await installClaudeDesktop(apiKey);
+      break;
+    case "codex":
+      await installCodex(apiKey);
+      break;
+    case "opencode":
+      await installOpenCode(apiKey, opts.global);
+      break;
+  }
+}
+async function installClaudeCode(apiKey, global) {
+  if (global) {
+    const claudeDir = join5(homedir2(), ".claude");
+    const settingsPath = join5(claudeDir, "settings.json");
+    await mkdir3(claudeDir, { recursive: true });
+    const settings = await readJsonSafe(settingsPath);
+    if (!settings.mcpServers) settings.mcpServers = {};
+    settings.mcpServers.recursiv = mcpServerEntry(apiKey);
+    await writeFile6(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    console.log(pc11.green("\u2713") + ` Recursiv MCP added to ${pc11.dim(settingsPath)}`);
+  } else {
+    const mcpPath = join5(process.cwd(), ".mcp.json");
+    const config = await readJsonSafe(mcpPath);
+    if (!config.mcpServers) config.mcpServers = {};
+    config.mcpServers.recursiv = mcpServerEntry(apiKey);
+    await writeFile6(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    console.log(pc11.green("\u2713") + ` Recursiv MCP added to ${pc11.dim(mcpPath)}`);
+  }
+}
+function claudeDesktopConfigPath() {
+  const p = platform();
+  if (p === "darwin") {
+    return join5(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (p === "win32") {
+    return join5(process.env.APPDATA || join5(homedir2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  }
+  return join5(homedir2(), ".config", "claude", "claude_desktop_config.json");
+}
+async function installClaudeDesktop(apiKey) {
+  const configPath2 = claudeDesktopConfigPath();
+  const dir = resolve3(configPath2, "..");
+  await mkdir3(dir, { recursive: true });
+  const config = await readJsonSafe(configPath2);
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers.recursiv = mcpServerEntry(apiKey);
+  await writeFile6(configPath2, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  console.log(pc11.green("\u2713") + ` Recursiv MCP added to ${pc11.dim(configPath2)}`);
+  console.log(pc11.dim("  Restart Claude Desktop to pick up the change."));
+}
+async function installCodex(apiKey) {
+  const codexDir = join5(homedir2(), ".codex");
+  const configPath2 = join5(codexDir, "config.toml");
+  await mkdir3(codexDir, { recursive: true });
+  let existing = "";
+  try {
+    existing = await readFile5(configPath2, "utf-8");
+  } catch {
+  }
+  existing = removeTomlSection(existing, "mcp_servers.recursiv");
+  const tomlBlock = [
+    "",
+    "[mcp_servers.recursiv]",
+    'command = "npx"',
+    'args = ["-y", "@recursiv/mcp"]',
+    "",
+    "[mcp_servers.recursiv.env]",
+    `RECURSIV_API_KEY = "${apiKey}"`
+  ].join("\n");
+  const final = existing.trimEnd() + "\n" + tomlBlock + "\n";
+  await writeFile6(configPath2, final, "utf-8");
+  console.log(pc11.green("\u2713") + ` Recursiv MCP added to ${pc11.dim(configPath2)}`);
+}
+async function installOpenCode(apiKey, global) {
+  let configPath2;
+  if (global) {
+    const configDir = join5(homedir2(), ".config", "opencode");
+    await mkdir3(configDir, { recursive: true });
+    configPath2 = join5(configDir, "opencode.json");
+  } else {
+    configPath2 = join5(process.cwd(), "opencode.json");
+  }
+  const config = await readJsonSafe(configPath2);
+  if (!config.mcp) config.mcp = {};
+  config.mcp.recursiv = {
+    type: "local",
+    command: ["npx", "-y", "@recursiv/mcp"],
+    enabled: true,
+    environment: {
+      RECURSIV_API_KEY: apiKey
+    }
+  };
+  await writeFile6(configPath2, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  console.log(pc11.green("\u2713") + ` Recursiv MCP added to ${pc11.dim(configPath2)}`);
+}
+async function mcpVerifyCommand() {
+  const { spawn: spawn2 } = await import("child_process");
+  const apiKey = process.env.RECURSIV_API_KEY || process.env.SOCIAL_DEV_API_KEY;
+  if (!apiKey) {
+    console.error(pc11.red("  error") + " RECURSIV_API_KEY not set in environment.");
+    process.exit(1);
+  }
+  console.log(pc11.dim("  Verifying Recursiv MCP server..."));
+  const child = spawn2("npx", ["-y", "@recursiv/mcp"], {
+    env: { ...process.env, RECURSIV_API_KEY: apiKey },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const initRequest = JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "recursiv-cli", version: "0.1.4" }
+    }
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  child.stdin.write(initRequest + "\n");
+  const result = await Promise.race([
+    new Promise((resolve4) => {
+      const check = setInterval(() => {
+        if (stdout.includes('"result"')) {
+          clearInterval(check);
+          resolve4("ok");
+        }
+        if (stdout.includes('"error"') || stderr.includes("Missing")) {
+          clearInterval(check);
+          resolve4("error");
+        }
+      }, 100);
+    }),
+    new Promise((resolve4) => setTimeout(() => resolve4("timeout"), 1e4))
+  ]);
+  child.kill();
+  switch (result) {
+    case "ok":
+      console.log(pc11.green("  \u2713") + " MCP server responded successfully.");
+      try {
+        const parsed = JSON.parse(stdout.trim().split("\n").pop() || "{}");
+        const serverName = parsed?.result?.serverInfo?.name;
+        const version = parsed?.result?.serverInfo?.version;
+        if (serverName) {
+          console.log(pc11.dim(`  Server: ${serverName} v${version || "?"}`));
+        }
+      } catch {
+      }
+      break;
+    case "error":
+      console.error(pc11.red("  \u2717") + " MCP server returned an error.");
+      if (stderr) console.error(pc11.dim(`  ${stderr.trim()}`));
+      process.exit(1);
+      break;
+    case "timeout":
+      console.error(pc11.red("  \u2717") + " MCP server did not respond within 10s.");
+      process.exit(1);
+      break;
+  }
+}
+function mcpServerEntry(apiKey) {
+  return {
+    command: "npx",
+    args: ["-y", "@recursiv/mcp"],
+    env: {
+      RECURSIV_API_KEY: apiKey
+    }
+  };
+}
+async function readJsonSafe(path) {
+  try {
+    const raw = await readFile5(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function removeTomlSection(content, section) {
+  const lines = content.split("\n");
+  const result = [];
+  let skipping = false;
+  const sectionHeader = `[${section}]`;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === sectionHeader || trimmed.startsWith(`[${section}.`)) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && trimmed.startsWith("[")) {
+      skipping = false;
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+var VALID_TARGETS;
+var init_mcp_install = __esm({
+  "src/commands/mcp-install.ts"() {
+    "use strict";
+    VALID_TARGETS = ["claude-code", "claude-desktop", "codex", "opencode"];
+  }
+});
+
+// src/chat/renderer.ts
+import pc12 from "picocolors";
+function getWidth() {
+  return Math.max((process.stdout.columns || 80) - INDENT.length, 40);
+}
+function wordWrap(text, width, indent = INDENT) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    if (paragraph.length <= width) {
+      lines.push(indent + paragraph);
+      continue;
+    }
+    const words = paragraph.split(/(\s+)/);
+    let current = "";
+    for (const word of words) {
+      if (current.length + word.length > width && current.length > 0) {
+        lines.push(indent + current.trimEnd());
+        current = word.trimStart();
+      } else {
+        current += word;
+      }
+    }
+    if (current.trimEnd()) lines.push(indent + current.trimEnd());
+  }
+  return lines.join("\n");
+}
+function colorize(text) {
+  text = text.replace(/(https?:\/\/[^\s)\]>]+)/g, pc12.cyan(pc12.underline("$1")));
+  text = text.replace(/`([^`]+)`/g, pc12.yellow("`$1`"));
+  text = text.replace(/\*\*([^*]+)\*\*/g, pc12.bold("$1"));
+  text = text.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, pc12.italic("$1"));
+  return text;
+}
+function printBanner(opts) {
+  const v = opts?.version ?? "0.1.4";
+  const logo = [
+    pc12.cyan("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"),
+    pc12.cyan("  \u2502 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510 \u2502"),
+    pc12.cyan("  \u2502 \u2502 \u250C\u2500\u2500\u2500\u2500\u2500\u2510 \u2502 \u2502") + "   " + pc12.bold(pc12.cyan("recursiv")) + pc12.dim(` v${v}`),
+    pc12.cyan("  \u2502 \u2502 \u2502 \u250C\u2500\u2510 \u2502 \u2502 \u2502") + "   " + pc12.dim("https://recursiv.io"),
+    pc12.cyan("  \u2502 \u2502 \u2502 \u2514\u2500\u2518 \u2502 \u2502 \u2502"),
+    pc12.cyan("  \u2502 \u2502 \u2514\u2500\u2500\u2500\u2500\u2500\u2518 \u2502 \u2502"),
+    pc12.cyan("  \u2502 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518 \u2502"),
+    pc12.cyan("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")
+  ];
+  console.log();
+  for (const line of logo) {
+    console.log(line);
+  }
+  console.log();
+  if (opts?.email || opts?.username) {
+    const identity = opts.email ? `${opts.username ? pc12.bold(`@${opts.username}`) : "signed in"} ${pc12.dim(`(${opts.email})`)}` : pc12.bold(`@${opts.username}`);
+    console.log(pc12.dim("  ") + identity);
+  }
+  if (opts?.resumed) {
+    console.log(
+      pc12.dim("  ") + pc12.dim(`resumed session ${opts.resumed.id} (${opts.resumed.messageCount} messages)`)
+    );
+  }
+  console.log();
+  console.log(pc12.dim("  Type a message to get started. /help for commands. Ctrl-D to exit."));
+}
+function printPrompt() {
+  process.stdout.write(pc12.bold(pc12.green("> ")));
+}
+function printTips(context = "welcome") {
+  const tips = HINT_MAP[context] || HINT_MAP.default;
+  console.log();
+  for (const [cmd, desc] of tips) {
+    console.log(
+      INDENT + pc12.dim("  ") + pc12.cyan(cmd) + pc12.dim(` \u2014 ${desc}`)
+    );
+  }
+  console.log();
+}
+function detectHintContext(responseText) {
+  const lower = responseText.toLowerCase();
+  if (lower.includes("created") && lower.includes("project")) return "project_created";
+  if (lower.includes("deployed") || lower.includes("deployment")) return "deployed";
+  if (lower.includes("created") && lower.includes("agent")) return "agent_created";
+  if (lower.includes("sandbox") && lower.includes("start")) return "sandbox_started";
+  if (lower.includes("executed") || lower.includes("output:")) return "code_executed";
+  if (lower.includes("projects") && (lower.includes("list") || lower.includes("|"))) return "listed_projects";
+  return "default";
+}
+function printAssistantLabel() {
+  console.log();
+  process.stdout.write(pc12.bold(pc12.cyan("recursiv ")) + "\n");
+}
+function printToolCall(name) {
+  console.log(pc12.yellow("  \u25B8 ") + pc12.dim(name));
+}
+function printToolResult(name, success) {
+  if (success) {
+    console.log(pc12.green("  \u2713 ") + pc12.dim(name));
+  } else {
+    console.log(pc12.red("  \u2717 ") + pc12.dim(name));
+  }
+}
+function startThinking() {
+  const frames = ["   \xB7", "   \xB7\xB7", "   \xB7\xB7\xB7"];
+  let i = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${pc12.dim(frames[i % frames.length])}  `);
+    i++;
+  }, 250);
+  return {
+    stop() {
+      clearInterval(interval);
+      process.stdout.write("\r\x1B[0K");
+    }
+  };
+}
+async function confirmAction(description) {
+  const { createInterface: createInterface2 } = await import("readline");
+  const rl = createInterface2({ input: process.stdin, output: process.stdout, terminal: true });
+  return new Promise((resolve4) => {
+    process.stdout.write(
+      pc12.yellow("  ? ") + description + pc12.dim(" (y/n) ")
+    );
+    rl.once("line", (line) => {
+      rl.close();
+      const answer = line.trim().toLowerCase();
+      resolve4(answer === "y" || answer === "yes");
+    });
+    rl.once("close", () => resolve4(false));
+  });
+}
+function printError(message) {
+  console.log(pc12.red("  \u2717 ") + message);
+}
+function printInfo(message) {
+  console.log(pc12.dim(message));
+}
+var INDENT, StreamWriter, HINT_MAP;
+var init_renderer = __esm({
+  "src/chat/renderer.ts"() {
+    "use strict";
+    INDENT = "  ";
+    StreamWriter = class {
+      buffer = "";
+      lineBuffer = "";
+      inCodeBlock = false;
+      write(chunk) {
+        this.buffer += chunk;
+        for (const char of chunk) {
+          this.lineBuffer += char;
+          if (char === "\n") {
+            this.flushLine();
+          }
+        }
+      }
+      flushLine() {
+        const line = this.lineBuffer;
+        this.lineBuffer = "";
+        const width = getWidth();
+        if (line.trimStart().startsWith("```")) {
+          this.inCodeBlock = !this.inCodeBlock;
+          process.stdout.write(INDENT + pc12.dim(line));
+          return;
+        }
+        if (this.inCodeBlock) {
+          process.stdout.write(INDENT + pc12.cyan(line));
+          return;
+        }
+        if (line.trim() === "") {
+          process.stdout.write("\n");
+          return;
+        }
+        const headingMatch = line.match(/^(#{1,3})\s+(.+)\n?$/);
+        if (headingMatch) {
+          process.stdout.write(INDENT + pc12.bold(pc12.cyan(headingMatch[2])) + "\n");
+          return;
+        }
+        if (/^---+\s*\n?$/.test(line)) {
+          process.stdout.write(INDENT + pc12.dim("\u2500".repeat(Math.min(width, 60))) + "\n");
+          return;
+        }
+        const bulletMatch = line.match(/^(\s*)([-*])\s+(.*)$/);
+        if (bulletMatch) {
+          const extraIndent = bulletMatch[1];
+          const content = colorize(bulletMatch[3]);
+          const prefix = INDENT + extraIndent + pc12.cyan("\u2022") + " ";
+          process.stdout.write(prefix + content + "\n");
+          return;
+        }
+        const numMatch = line.match(/^(\s*)(\d+)\.\s+(.*)$/);
+        if (numMatch) {
+          const extraIndent = numMatch[1];
+          const num = numMatch[2];
+          const content = colorize(numMatch[3]);
+          const prefix = INDENT + extraIndent + pc12.cyan(num + ".") + " ";
+          process.stdout.write(prefix + content + "\n");
+          return;
+        }
+        const trimmed = line.replace(/\n$/, "");
+        const wrapped = wordWrap(trimmed, width);
+        process.stdout.write(colorize(wrapped) + "\n");
+      }
+      getBuffer() {
+        return this.buffer;
+      }
+      finishAndRender() {
+        if (this.lineBuffer) {
+          const remaining = this.lineBuffer;
+          this.lineBuffer = "";
+          if (this.inCodeBlock) {
+            process.stdout.write(pc12.cyan(remaining));
+          } else {
+            process.stdout.write(colorize(remaining));
+          }
+        }
+      }
+    };
+    HINT_MAP = {
+      welcome: [
+        ["build an app", "create & deploy a project"],
+        ["create an agent", "spin up an AI agent"],
+        ["run some code", "execute in a sandbox"],
+        ["show my projects", "list everything you've built"]
+      ],
+      project_created: [
+        ["deploy it", "push to production"],
+        ["add an agent", "attach AI to this project"],
+        ["start a sandbox", "spin up a dev environment"],
+        ["show my projects", "see all projects"]
+      ],
+      deployed: [
+        ["check deploy status", "view deployment state"],
+        ["view logs", "see deployment logs"],
+        ["create another project", "start something new"]
+      ],
+      agent_created: [
+        ["chat with it", "talk to your agent"],
+        ["schedule a task", "set up recurring work"],
+        ["create a swarm", "coordinate multiple agents"]
+      ],
+      sandbox_started: [
+        ["run some code", "execute in the sandbox"],
+        ["deploy it", "push to production"],
+        ["stop sandbox", "tear down environment"]
+      ],
+      code_executed: [
+        ["run more code", "iterate in the sandbox"],
+        ["deploy it", "push to production"],
+        ["show my projects", "see all projects"]
+      ],
+      listed_projects: [
+        ["deploy <name>", "deploy a specific project"],
+        ["build something new", "create a new project"],
+        ["create an agent", "add AI to a project"]
+      ],
+      default: [
+        ["build an app", "create & deploy a project"],
+        ["show my projects", "see what you've built"],
+        ["create an agent", "spin up an AI agent"]
+      ]
+    };
+  }
+});
+
+// src/chat/session.ts
+import { readFile as readFile6, writeFile as writeFile7, mkdir as mkdir4 } from "fs/promises";
+import { join as join6 } from "path";
+import { homedir as homedir3 } from "os";
+import { randomUUID } from "crypto";
+function createSession() {
+  return {
+    id: randomUUID(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    messages: []
+  };
+}
+async function saveSession(session) {
+  await mkdir4(SESSIONS_DIR, { recursive: true });
+  const path = join6(SESSIONS_DIR, `${session.id}.json`);
+  const trimmed = {
+    ...session,
+    messages: session.messages.slice(-MAX_HISTORY_MESSAGES)
+  };
+  await writeFile7(path, JSON.stringify(trimmed, null, 2), "utf-8");
+}
+async function loadLatestSession() {
+  try {
+    const { readdir, stat } = await import("fs/promises");
+    const files = await readdir(SESSIONS_DIR);
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    if (jsonFiles.length === 0) return null;
+    let latest = "";
+    let latestTime = 0;
+    for (const file of jsonFiles) {
+      const info = await stat(join6(SESSIONS_DIR, file));
+      if (info.mtimeMs > latestTime) {
+        latestTime = info.mtimeMs;
+        latest = file;
+      }
+    }
+    if (!latest) return null;
+    const raw = await readFile6(join6(SESSIONS_DIR, latest), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function loadSession(id) {
+  try {
+    const raw = await readFile6(join6(SESSIONS_DIR, `${id}.json`), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function listSessions(limit = 10) {
+  try {
+    const { readdir, stat } = await import("fs/promises");
+    const files = await readdir(SESSIONS_DIR);
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    const entries = [];
+    for (const file of jsonFiles) {
+      try {
+        const filePath = join6(SESSIONS_DIR, file);
+        const info = await stat(filePath);
+        const raw = await readFile6(filePath, "utf-8");
+        const session = JSON.parse(raw);
+        entries.push({
+          id: session.id,
+          createdAt: session.createdAt,
+          messageCount: session.messages.length,
+          updatedAt: info.mtime
+        });
+      } catch {
+      }
+    }
+    entries.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+    return entries.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+function addUserMessage(session, content) {
+  session.messages.push({ role: "user", content });
+}
+function addAssistantMessage(session, content) {
+  session.messages.push({ role: "assistant", content });
+}
+function addToolResult(session, toolUseId, result, isError = false) {
+  session.messages.push({
+    role: "user",
+    content: [
+      {
+        type: "tool_result",
+        tool_use_id: toolUseId,
+        content: result,
+        is_error: isError
+      }
+    ]
+  });
+}
+var SESSIONS_DIR, MAX_HISTORY_MESSAGES;
+var init_session = __esm({
+  "src/chat/session.ts"() {
+    "use strict";
+    SESSIONS_DIR = join6(homedir3(), ".recursiv", "sessions");
+    MAX_HISTORY_MESSAGES = 100;
+  }
+});
+
+// src/chat/system-prompt.ts
+var system_prompt_exports = {};
+__export(system_prompt_exports, {
+  buildSystemPrompt: () => buildSystemPrompt
+});
+function buildSystemPrompt(context) {
+  return `You are Recursiv \u2014 a CLI agent that builds, deploys, and runs software on the Recursiv platform.
+
+## Current user
+${context.username ? `- Username: @${context.username}` : "- Not yet identified (call get_my_profile)"}
+${context.email ? `- Email: ${context.email}` : ""}
+- API: ${context.apiBaseUrl}
+
+## Your capabilities
+
+You have the full Recursiv toolchain. Use it:
+
+- **Projects**: create_project, list_projects, get_project, deploy_project
+- **Deployments**: deploy_project (preview or production), get_deployment, get_deployment_logs
+- **Sandboxes**: start_sandbox, stop_sandbox, execute_code (run code inside a project sandbox)
+- **Code execution**: try_code (quick sandbox, no project needed), execute_code (project sandbox)
+- **Agents**: create_agent, list_agents, get_agent, update_agent, chat_with_agent
+- **Templates**: create_template, fork_template, publish_template, list_templates
+- **Social**: create_post, list_posts, search_posts, list_communities
+- **Orgs**: list_orgs (always call first to get the user's org)
+- **Dispatcher**: create_task, list_tasks, claim_task, complete_task
+- **Swarms**: create_swarm, activate_swarm, add_swarm_member
+- **Memory**: remember, recall, search_memory
+
+## How you work
+
+You are an executor. You have tools. Use them.
+
+When the user asks you to build something:
+1. list_orgs \u2192 get their org ID
+2. create_project \u2192 name it based on what they described
+3. start_sandbox \u2192 spin up the project environment
+4. execute_code \u2192 write the actual application code in the sandbox
+5. deploy_project \u2192 deploy it
+6. create_agent if the project needs AI
+7. Report: project name, ID, deployment status, and what's running
+
+When the user asks to run code:
+1. try_code or execute_code \u2014 run it immediately, return the output
+
+When the user asks to deploy:
+1. deploy_project with the project ID
+2. get_deployment to check status
+3. Report the deployment status/URL
+
+## Output style
+
+- ONE LINE summary of what you did
+- Project name + ID + deployment status. That's it.
+- No code dumps. You WRITE code into sandboxes via execute_code, you don't paste it into chat.
+- If you must show code in chat, max 5 lines of the key logic.
+
+## Rules
+
+1. ALWAYS USE TOOLS. You ARE the platform. Never tell users to run commands.
+2. ALWAYS create projects inside the user's org. Call list_orgs first.
+3. Use execute_code and start_sandbox to actually build \u2014 don't just describe architecture.
+4. Never dump code into chat. Write it into the sandbox.
+5. Never reference external brands as infrastructure. Everything is Recursiv.
+6. Never ask "would you like me to" \u2014 just do it.
+7. Short responses. Action over discussion.
+
+## Tone
+Precise. Efficient. Slightly warm. Senior engineer energy.`;
+}
+var init_system_prompt = __esm({
+  "src/chat/system-prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/chat/tools.ts
+var tools_exports = {};
+__export(tools_exports, {
+  describeToolAction: () => describeToolAction,
+  executeTool: () => executeTool,
+  getToolDefinitions: () => getToolDefinitions,
+  requiresConfirmation: () => requiresConfirmation
+});
+function tool(name, description, properties = {}, required = []) {
+  return {
+    name,
+    description,
+    input_schema: {
+      type: "object",
+      properties,
+      required
+    }
+  };
+}
+function getToolDefinitions() {
+  return [
+    // --- Profile & Identity ---
+    tool("get_my_profile", "Get the authenticated user's profile"),
+    tool("get_profile", "Get a user profile by ID", {
+      user_id: { type: "string", description: "User ID" }
+    }, ["user_id"]),
+    tool("get_profile_by_username", "Get a user profile by username", {
+      username: { type: "string", description: "Username (without @)" }
+    }, ["username"]),
+    tool("search_profiles", "Search for users", {
+      query: { type: "string", description: "Search query" },
+      limit: { type: "number", description: "Max results (default 20)" }
+    }, ["query"]),
+    tool("update_profile", "Update the current user's profile", {
+      name: { type: "string" },
+      bio: { type: "string" },
+      location: { type: "string" },
+      website: { type: "string" }
+    }),
+    tool("follow_user", "Follow a user", {
+      user_id: { type: "string", description: "User ID to follow" }
+    }, ["user_id"]),
+    tool("unfollow_user", "Unfollow a user", {
+      user_id: { type: "string", description: "User ID to unfollow" }
+    }, ["user_id"]),
+    tool("get_followers", "Get followers of a user", {
+      user_id: { type: "string" },
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }, ["user_id"]),
+    tool("get_following", "Get users that a user follows", {
+      user_id: { type: "string" },
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }, ["user_id"]),
+    // --- Posts ---
+    tool("list_posts", "List posts from the feed", {
+      community_id: { type: "string", description: "Filter by community" },
+      author_id: { type: "string", description: "Filter by author" },
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }),
+    tool("get_post", "Get a specific post", {
+      post_id: { type: "string" }
+    }, ["post_id"]),
+    tool("create_post", "Create a new post", {
+      content: { type: "string", description: "Post content" },
+      content_format: { type: "string", enum: ["plain", "markdown"], description: "Content format (default: plain)" },
+      community_id: { type: "string", description: "Post to a specific community" },
+      organization_id: { type: "string" },
+      reply_to_id: { type: "string", description: "Reply to a post" }
+    }, ["content"]),
+    tool("update_post", "Update a post", {
+      post_id: { type: "string" },
+      content: { type: "string" }
+    }, ["post_id", "content"]),
+    tool("delete_post", "Delete a post", {
+      post_id: { type: "string" }
+    }, ["post_id"]),
+    tool("search_posts", "Search posts", {
+      query: { type: "string" },
+      limit: { type: "number" }
+    }, ["query"]),
+    tool("react_to_post", "React to a post with one of the allowed reaction types", {
+      post_id: { type: "string" },
+      reaction: { type: "string", enum: ["like", "heart", "fire", "laugh", "sad", "angry"], description: "Reaction type" }
+    }, ["post_id", "reaction"]),
+    // --- Communities ---
+    tool("list_communities", "List communities", {
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }),
+    tool("get_community", "Get a community by ID", {
+      community_id: { type: "string" }
+    }, ["community_id"]),
+    tool("create_community", "Create a new community", {
+      name: { type: "string" },
+      slug: { type: "string" },
+      description: { type: "string" },
+      privacy: { type: "string", enum: ["public", "private", "hidden"] }
+    }, ["name", "slug"]),
+    tool("join_community", "Join a community", {
+      community_id: { type: "string" }
+    }, ["community_id"]),
+    tool("leave_community", "Leave a community", {
+      community_id: { type: "string" }
+    }, ["community_id"]),
+    // --- Chat ---
+    tool("list_conversations", "List chat conversations", {
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }),
+    tool("list_messages", "List messages in a conversation", {
+      conversation_id: { type: "string" },
+      limit: { type: "number" },
+      before: { type: "string", description: "Cursor for pagination" }
+    }, ["conversation_id"]),
+    tool("send_message", "Send a chat message", {
+      conversation_id: { type: "string" },
+      content: { type: "string" }
+    }, ["conversation_id", "content"]),
+    tool("get_or_create_dm", "Get or create a DM conversation with a user", {
+      user_id: { type: "string" }
+    }, ["user_id"]),
+    tool("create_group_chat", "Create a group chat", {
+      name: { type: "string", description: "Group name" },
+      member_ids: { type: "array", items: { type: "string" }, description: "User IDs to add" }
+    }, ["name", "member_ids"]),
+    tool("get_unread_count", "Get unread message count for a conversation", {
+      conversation_id: { type: "string", description: "Conversation ID" }
+    }, ["conversation_id"]),
+    // --- Organizations ---
+    tool("list_orgs", "List organizations the user belongs to", {
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }),
+    tool("get_org", "Get organization details", {
+      org_id: { type: "string" }
+    }, ["org_id"]),
+    tool("create_org", "Create a new organization", {
+      name: { type: "string" },
+      slug: { type: "string" },
+      description: { type: "string" }
+    }, ["name", "slug"]),
+    tool("list_org_members", "List members of an organization", {
+      org_id: { type: "string" },
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }, ["org_id"]),
+    tool("invite_org_member", "Invite a user to an organization", {
+      org_id: { type: "string" },
+      email: { type: "string" },
+      role: { type: "string", enum: ["member", "admin", "owner"] }
+    }, ["org_id", "email"]),
+    // --- Projects ---
+    tool("list_projects", "List projects", {
+      organization_id: { type: "string" },
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }),
+    tool("get_project", "Get a project by ID", {
+      project_id: { type: "string" }
+    }, ["project_id"]),
+    tool("create_project", "Create a new project", {
+      organization_id: { type: "string" },
+      name: { type: "string" },
+      slug: { type: "string" },
+      repo_url: { type: "string" }
+    }, ["organization_id", "name"]),
+    // --- Agents ---
+    tool("list_agents", "List AI agents", {
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }),
+    tool("get_agent", "Get an agent by ID", {
+      agent_id: { type: "string" }
+    }, ["agent_id"]),
+    tool("create_agent", "Create an AI agent", {
+      name: { type: "string" },
+      username: { type: "string" },
+      bio: { type: "string" },
+      model: { type: "string" },
+      system_prompt: { type: "string" },
+      social_mode: { type: "string", enum: ["chat_only", "chat_post"] },
+      post_frequency: { type: "string", enum: ["never", "light", "medium", "heavy"] },
+      tool_mode: { type: "string", enum: ["chat_only", "permission", "autonomous"] },
+      organization_id: { type: "string" }
+    }, ["name", "username"]),
+    tool("update_agent", "Update an agent", {
+      agent_id: { type: "string" },
+      name: { type: "string" },
+      bio: { type: "string" },
+      system_prompt: { type: "string" },
+      social_mode: { type: "string" },
+      post_frequency: { type: "string" },
+      tool_mode: { type: "string" }
+    }, ["agent_id"]),
+    tool("delete_agent", "Delete an agent", {
+      agent_id: { type: "string" }
+    }, ["agent_id"]),
+    tool("chat_with_agent", "Send a message to an agent and get a response", {
+      agent_id: { type: "string" },
+      message: { type: "string" },
+      conversation_id: { type: "string", description: "Optional \u2014 continue existing conversation" }
+    }, ["agent_id", "message"]),
+    // --- Dispatcher ---
+    tool("list_tasks", "List dispatcher tasks", {
+      status: { type: "string", enum: ["pending", "in_progress", "claimed", "done"] },
+      owner: { type: "string" },
+      limit: { type: "number" }
+    }),
+    tool("create_task", "Create a dispatcher task", {
+      title: { type: "string" },
+      description: { type: "string" },
+      layer: { type: "string", enum: ["core", "plugin", "ops"] },
+      effort: { type: "number", description: "1-10 effort score" },
+      priority: { type: "number", description: "1-10 priority" }
+    }, ["title"]),
+    tool("claim_task", "Claim a task", {
+      task_id: { type: "string" },
+      agent: { type: "string", description: "Agent/person identifier" }
+    }, ["task_id", "agent"]),
+    tool("complete_task", "Mark a task as done", {
+      task_id: { type: "string" },
+      notes: { type: "string" }
+    }, ["task_id"]),
+    // --- Storage ---
+    tool("list_storage_buckets", "List storage buckets for a project", {
+      project_id: { type: "string" }
+    }, ["project_id"]),
+    tool("list_storage_items", "List items in a storage bucket", {
+      project_id: { type: "string" },
+      bucket_name: { type: "string" },
+      prefix: { type: "string" }
+    }, ["project_id", "bucket_name"]),
+    // --- Databases ---
+    tool("list_databases", "List databases for a project", {
+      project_id: { type: "string" }
+    }, ["project_id"]),
+    tool("run_sql_query", "Execute a SQL query against a project database", {
+      project_id: { type: "string" },
+      database_id: { type: "string" },
+      query: { type: "string", description: "SQL query to execute" }
+    }, ["project_id", "database_id", "query"]),
+    // --- Deployments ---
+    tool("list_deployments", "List deployments for a project", {
+      project_id: { type: "string" }
+    }, ["project_id"]),
+    tool("trigger_deployment", "Trigger a new deployment", {
+      project_id: { type: "string" },
+      environment: { type: "string", description: "Target environment" }
+    }, ["project_id"]),
+    // --- Memory ---
+    tool("remember", "Store a fact in agent memory", {
+      content: { type: "string", description: "What to remember" },
+      category: { type: "string", description: "Category tag" }
+    }, ["content"]),
+    tool("recall", "Recall memories matching a query", {
+      query: { type: "string" },
+      limit: { type: "number" }
+    }, ["query"]),
+    tool("search_memory", "Search memory with filters", {
+      query: { type: "string" },
+      category: { type: "string" },
+      limit: { type: "number" }
+    }, ["query"]),
+    // --- Sandbox ---
+    tool("execute_code", "Execute code in a sandboxed environment", {
+      code: { type: "string", description: "Code to execute" },
+      language: { type: "string", enum: ["python", "javascript", "typescript"], description: "Language (default: python)" }
+    }, ["code"]),
+    // --- Wallet ---
+    tool("get_my_wallet", "Get the user's wallet info"),
+    tool("get_wallet_balance", "Get wallet balance"),
+    // --- Network & Context ---
+    tool("get_network_config", "Get the current network configuration"),
+    tool("list_inbox", "List inbox notifications", {
+      limit: { type: "number" },
+      offset: { type: "number" }
+    }),
+    // --- Swarms ---
+    tool("list_swarms", "List agent swarms", {
+      limit: { type: "number" }
+    }),
+    tool("create_swarm", "Create a new agent swarm", {
+      name: { type: "string" },
+      description: { type: "string" },
+      member_agent_ids: { type: "array", items: { type: "string" } }
+    }, ["name", "member_agent_ids"]),
+    // --- Templates ---
+    tool("list_templates", "List available templates", {
+      limit: { type: "number" }
+    }),
+    // --- Billing ---
+    tool("get_billing_status", "Get billing status for the current user"),
+    tool("get_tier", "Get the user's current tier and limits"),
+    tool("get_tier_usage", "Get current tier usage statistics"),
+    // --- Admin (requires network admin role) ---
+    tool("admin_get_stats", "Get network-wide statistics. Requires: network admin."),
+    tool("admin_list_users", "List all users. Requires: network admin.", {
+      limit: { type: "number" },
+      offset: { type: "number" }
+    })
+  ];
+}
+function requiresConfirmation(name) {
+  return DESTRUCTIVE_TOOLS.has(name);
+}
+function describeToolAction(name, input) {
+  switch (name) {
+    case "delete_post":
+      return `Delete post ${input.post_id}`;
+    case "delete_agent":
+      return `Delete agent ${input.agent_id}`;
+    case "create_post": {
+      const content = input.content || "";
+      const preview = content.length > 60 ? content.slice(0, 57) + "..." : content;
+      return `Create post: "${preview}"`;
+    }
+    case "create_agent":
+      return `Create agent @${input.username}`;
+    case "create_org":
+      return `Create organization "${input.name}"`;
+    case "create_community":
+      return `Create community "${input.name}"`;
+    case "update_profile":
+      return "Update your profile";
+    case "send_message": {
+      const content = input.content || "";
+      const preview = content.length > 60 ? content.slice(0, 57) + "..." : content;
+      return `Send message: "${preview}"`;
+    }
+    case "invite_org_member":
+      return `Invite ${input.email} to organization`;
+    case "trigger_deployment":
+      return `Deploy project ${input.project_id}`;
+    case "run_sql_query": {
+      const sql = input.query || "";
+      const preview = sql.length > 60 ? sql.slice(0, 57) + "..." : sql;
+      return `Run SQL: ${preview}`;
+    }
+    case "execute_code":
+      return `Execute ${input.language || "python"} code in sandbox`;
+    case "create_swarm":
+      return `Create swarm "${input.name}"`;
+    case "create_task":
+      return `Create task "${input.title}"`;
+    case "complete_task":
+      return `Complete task ${input.task_id}`;
+    case "claim_task":
+      return `Claim task ${input.task_id}`;
+    case "follow_user":
+      return `Follow user ${input.user_id}`;
+    case "unfollow_user":
+      return `Unfollow user ${input.user_id}`;
+    case "join_community":
+      return `Join community ${input.community_id}`;
+    case "leave_community":
+      return `Leave community ${input.community_id}`;
+    case "react_to_post":
+      return `React ${input.reaction} to post ${input.post_id}`;
+    default:
+      return `${name}(${Object.keys(input).join(", ")})`;
+  }
+}
+async function executeTool(client, name, input) {
+  switch (name) {
+    // --- Profile ---
+    case "get_my_profile":
+      return client.profiles.me();
+    case "get_profile":
+      return client.profiles.get(input.user_id);
+    case "get_profile_by_username":
+      return client.profiles.getByUsername(input.username);
+    case "search_profiles":
+      return client.profiles.search({
+        q: input.query,
+        limit: input.limit
+      });
+    case "update_profile":
+      return client.profiles.update(input);
+    case "follow_user":
+      return client.profiles.follow(input.user_id);
+    case "unfollow_user":
+      return client.profiles.unfollow(input.user_id);
+    case "get_followers":
+      return client.profiles.followers(input.user_id, {
+        limit: input.limit,
+        offset: input.offset
+      });
+    case "get_following":
+      return client.profiles.following(input.user_id, {
+        limit: input.limit,
+        offset: input.offset
+      });
+    // --- Posts ---
+    case "list_posts":
+      return client.posts.list(input);
+    case "get_post":
+      return client.posts.get(input.post_id);
+    case "create_post":
+      return client.posts.create(input);
+    case "update_post":
+      return client.posts.update(input.post_id, { content: input.content });
+    case "delete_post":
+      return client.posts.delete(input.post_id);
+    case "search_posts":
+      return client.posts.search(input);
+    case "react_to_post":
+      return client.posts.react(
+        input.post_id,
+        input.reaction
+      );
+    // --- Communities ---
+    case "list_communities":
+      return client.communities.list(input);
+    case "get_community":
+      return client.communities.get(input.community_id);
+    case "create_community":
+      return client.communities.create(input);
+    case "join_community":
+      return client.communities.join(input.community_id);
+    case "leave_community":
+      return client.communities.leave(input.community_id);
+    // --- Chat ---
+    case "list_conversations":
+      return client.chat.conversations(input);
+    case "list_messages":
+      return client.chat.messages(input.conversation_id, {
+        limit: input.limit
+      });
+    case "send_message":
+      return client.chat.send({
+        conversation_id: input.conversation_id,
+        content: input.content
+      });
+    case "get_or_create_dm":
+      return client.chat.dm({ user_id: input.user_id });
+    case "create_group_chat":
+      return client.chat.createGroup({
+        name: input.name,
+        member_ids: input.member_ids
+      });
+    case "get_unread_count":
+      return client.chat.unreadCount(input.conversation_id);
+    // --- Organizations ---
+    case "list_orgs":
+      return client.organizations.list(input);
+    case "get_org":
+      return client.organizations.get(input.org_id);
+    case "create_org":
+      return client.organizations.create(input);
+    case "list_org_members":
+      return client.organizations.members(input.org_id, {
+        limit: input.limit,
+        offset: input.offset
+      });
+    case "invite_org_member":
+      return client.organizations.invite(input.org_id, {
+        email: input.email,
+        role: input.role
+      });
+    // --- Projects ---
+    case "list_projects":
+      return client.projects.list(input);
+    case "get_project":
+      return client.projects.get(input.project_id);
+    case "create_project":
+      return client.projects.create(input);
+    // --- Agents ---
+    case "list_agents":
+      return client.agents.list(input);
+    case "get_agent":
+      return client.agents.get(input.agent_id);
+    case "create_agent":
+      return client.agents.create(input);
+    case "update_agent":
+      return client.agents.update(input.agent_id, input);
+    case "delete_agent":
+      return client.agents.delete(input.agent_id);
+    case "chat_with_agent":
+      return client.agents.chat(input.agent_id, {
+        message: input.message,
+        conversation_id: input.conversation_id
+      });
+    // --- Dispatcher ---
+    case "list_tasks":
+      return client.dispatcher.tasks(input);
+    case "create_task":
+      return client.dispatcher.create(input);
+    case "claim_task":
+      return client.dispatcher.claim(input.task_id, {
+        agent: input.agent
+      });
+    case "complete_task":
+      return client.dispatcher.complete(input.task_id, {
+        notes: input.notes
+      });
+    // --- Storage ---
+    case "list_storage_buckets":
+      return client.storage.listBuckets({ project_id: input.project_id });
+    case "list_storage_items":
+      return client.storage.listItems({
+        project_id: input.project_id,
+        bucket_name: input.bucket_name,
+        prefix: input.prefix
+      });
+    // --- Databases ---
+    case "list_databases":
+      return client.databases.list({ project_id: input.project_id });
+    case "run_sql_query":
+      return client.databases.query({
+        project_id: input.project_id,
+        sql: input.query,
+        database_name: input.database_id
+      });
+    // --- Deployments ---
+    case "list_deployments":
+      return client.deployments.list({ project_id: input.project_id });
+    case "trigger_deployment":
+      return client.deployments.deploy({
+        project_id: input.project_id,
+        branch: input.environment
+      });
+    // --- Memory ---
+    case "remember":
+      return client.memory.facts.add({
+        fact: input.content
+      });
+    case "recall":
+      return client.memory.search({
+        query: input.query,
+        limit: input.limit
+      });
+    case "search_memory":
+      return client.memory.search({
+        query: input.query,
+        limit: input.limit
+      });
+    // --- Sandbox ---
+    case "execute_code":
+      return client.sandbox.execute({
+        code: input.code,
+        language: input.language || "python"
+      });
+    // --- Wallet ---
+    case "get_my_wallet":
+      return client.wallet.getMyWallet();
+    case "get_wallet_balance":
+      return client.wallet.getBalance();
+    // --- Network & Context ---
+    case "get_network_config":
+      return client.network.getConfig();
+    case "list_inbox":
+      return client.inbox.list(input);
+    // --- Swarms ---
+    case "list_swarms":
+      return client.swarms.list(input);
+    case "create_swarm":
+      return client.swarms.create(input);
+    // --- Templates ---
+    case "list_templates":
+      return client.templates.list(input);
+    // --- Billing ---
+    case "get_billing_status":
+      return client.billing.getStatus({});
+    case "get_tier":
+      return client.freeTier.getTier();
+    case "get_tier_usage":
+      return client.freeTier.getUsage();
+    // --- Admin ---
+    case "admin_get_stats":
+      return client.admin.getStats();
+    case "admin_list_users":
+      return client.admin.listUsers(input);
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+var DESTRUCTIVE_TOOLS;
+var init_tools = __esm({
+  "src/chat/tools.ts"() {
+    "use strict";
+    DESTRUCTIVE_TOOLS = /* @__PURE__ */ new Set([
+      "delete_post",
+      "delete_agent",
+      "create_post",
+      "create_agent",
+      "create_org",
+      "create_community",
+      "update_profile",
+      "send_message",
+      "invite_org_member",
+      "trigger_deployment",
+      "run_sql_query",
+      "execute_code",
+      "create_swarm",
+      "create_task",
+      "complete_task",
+      "claim_task",
+      "follow_user",
+      "unfollow_user",
+      "join_community",
+      "leave_community",
+      "react_to_post"
+    ]);
+  }
+});
+
+// src/chat/agent.ts
+var agent_exports = {};
+__export(agent_exports, {
+  startAgent: () => startAgent
+});
+import { createInterface } from "readline";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { basename as basename2, join as join7 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { Recursiv } from "@recursiv/sdk";
+import pc13 from "picocolors";
+async function startAgent(config) {
+  const client = new Recursiv({
+    apiKey: config.recursivApiKey,
+    baseUrl: config.recursivBaseUrl
+  });
+  let username;
+  let email;
+  try {
+    const profile = await client.profiles.me();
+    const data = profile.data;
+    username = data?.username;
+    email = data?.email;
+  } catch {
+  }
+  let session;
+  if (config.resume) {
+    const prev = await loadLatestSession();
+    if (prev) {
+      session = prev;
+    } else {
+      session = createSession();
+    }
+  } else {
+    session = createSession();
+  }
+  printBanner({
+    username,
+    email,
+    resumed: config.resume && session.messages.length > 0 ? { id: session.id.slice(0, 8), messageCount: session.messages.length } : void 0
+  });
+  console.log();
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  rl.on("close", async () => {
+    console.log();
+    printInfo("Session saved. Goodbye.");
+    await saveSession(session);
+    process.exit(0);
+  });
+  if (config.anthropicApiKey) {
+    await replDirect(rl, config, client, session);
+  } else {
+    await replProxy(rl, client, session);
+  }
+}
+async function replProxy(rl, client, session) {
+  const { readCredentials: readCredentials2, saveCredentials: saveCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const creds = await readCredentials2();
+  let agentId = creds.cliAgentId;
+  if (!agentId) {
+    try {
+      let orgId;
+      try {
+        const orgs = await client.organizations.list({ limit: 1 });
+        const orgData = orgs.data;
+        if (orgData?.[0]?.id) orgId = orgData[0].id;
+      } catch {
+      }
+      const result = await client.agents.create({
+        name: "CLI Assistant",
+        username: `cli_${Date.now().toString(36)}`,
+        bio: "Personal CLI assistant created by the Recursiv CLI.",
+        system_prompt: CLI_AGENT_SYSTEM_PROMPT,
+        social_mode: "chat_only",
+        tool_mode: "autonomous",
+        post_frequency: "never",
+        ...orgId && { organization_id: orgId }
+      });
+      agentId = result.data.id;
+      await saveCredentials2({ cliAgentId: agentId });
+      printInfo(`  Created CLI agent (${agentId.slice(0, 8)})`);
+    } catch (err) {
+      printError(`Could not create CLI agent: ${err instanceof Error ? err.message : String(err)}`);
+      printInfo("  Falling back to direct mode. Set ANTHROPIC_API_KEY to use.");
+      return;
+    }
+  }
+  let conversationId;
+  const isFirstRun = session.messages.length === 0;
+  if (isFirstRun) {
+    const ctx = detectProjectContext();
+    printFirstRunGreeting(ctx);
+  }
+  while (true) {
+    const input = await prompt(rl);
+    if (input === null) break;
+    const trimmed = input.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("/")) {
+      const handled = await handleSlashCommand(trimmed, session, client);
+      if (handled === "exit") break;
+      if (handled) continue;
+    }
+    addUserMessage(session, trimmed);
+    const messageToSend = planMode ? `[PLAN MODE] Do NOT execute anything yet. Instead, outline the steps you would take to accomplish this, what tools you'd call and in what order. Wait for my approval before executing.
+
+${trimmed}` : trimmed;
+    try {
+      if (planMode) {
+        console.log(pc13.dim("  \u25C6 plan mode"));
+      }
+      printAssistantLabel();
+      const thinking = startThinking();
+      const writer = new StreamWriter();
+      let hasText = false;
+      let thinkingStopped = false;
+      for await (const chunk of client.agents.chatStream(agentId, {
+        message: messageToSend,
+        conversation_id: conversationId
+      })) {
+        if (chunk.type === "text_delta" && chunk.delta) {
+          if (!thinkingStopped) {
+            thinking.stop();
+            thinkingStopped = true;
+          }
+          hasText = true;
+          writer.write(chunk.delta);
+        } else if (chunk.type === "tool_use" && chunk.tool_name) {
+          if (!thinkingStopped) {
+            thinking.stop();
+            thinkingStopped = true;
+          }
+          printToolCall(chunk.tool_name);
+        } else if (chunk.type === "tool_result") {
+          printToolResult(chunk.tool_name || "tool", true);
+        } else if (chunk.type === "error") {
+          if (!thinkingStopped) {
+            thinking.stop();
+            thinkingStopped = true;
+          }
+          printError(chunk.error || "Unknown error");
+        }
+        if (chunk.conversation_id) {
+          conversationId = chunk.conversation_id;
+        }
+      }
+      if (!thinkingStopped) thinking.stop();
+      if (hasText) {
+        writer.finishAndRender();
+      }
+      console.log();
+      const fullText = writer.getBuffer() || "";
+      if (fullText) {
+        addAssistantMessage(session, [{ type: "text", text: fullText }]);
+        const hintCtx = detectHintContext(fullText);
+        printTips(hintCtx);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("rate_limit") || message.includes("429")) {
+        printError("Rate limited \u2014 wait a moment and try again.");
+      } else if (message.includes("401") || message.includes("authentication")) {
+        printError("API key is invalid. Run `recursiv auth login` to re-authenticate.");
+      } else if (message.includes("ENOTFOUND") || message.includes("ECONNREFUSED")) {
+        printError("Network error \u2014 check your internet connection.");
+      } else {
+        printError(message);
+      }
+      console.log();
+    }
+    await saveSession(session);
+  }
+}
+async function replDirect(rl, config, client, session) {
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const { buildSystemPrompt: buildSystemPrompt2 } = await Promise.resolve().then(() => (init_system_prompt(), system_prompt_exports));
+  const { getToolDefinitions: getToolDefinitions2, executeTool: executeTool2, requiresConfirmation: requiresConfirmation2, describeToolAction: describeToolAction2 } = await Promise.resolve().then(() => (init_tools(), tools_exports));
+  const anthropic = new Anthropic({ apiKey: config.anthropicApiKey });
+  const tools = getToolDefinitions2();
+  const model = config.model || DEFAULT_MODEL;
+  let username;
+  let email;
+  try {
+    const profile = await client.profiles.me();
+    const data = profile.data;
+    username = data?.username;
+    email = data?.email;
+  } catch {
+  }
+  const systemPrompt = buildSystemPrompt2({
+    username,
+    email,
+    apiBaseUrl: config.recursivBaseUrl
+  });
+  while (true) {
+    const input = await prompt(rl);
+    if (input === null) break;
+    const trimmed = input.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("/")) {
+      const handled = await handleSlashCommand(trimmed, session, client);
+      if (handled === "exit") break;
+      if (handled) continue;
+    }
+    addUserMessage(session, trimmed);
+    await runDirectTurn(anthropic, client, tools, model, systemPrompt, session);
+    await saveSession(session);
+  }
+}
+async function runDirectTurn(anthropic, client, tools, model, systemPrompt, session) {
+  const { requiresConfirmation: requiresConfirmation2, describeToolAction: describeToolAction2, executeTool: executeTool2 } = await Promise.resolve().then(() => (init_tools(), tools_exports));
+  let rounds = 0;
+  while (rounds < MAX_TOOL_ROUNDS) {
+    rounds++;
+    try {
+      printAssistantLabel();
+      const thinking = startThinking();
+      const stream = anthropic.messages.stream({
+        model,
+        max_tokens: MAX_TOKENS,
+        system: systemPrompt,
+        tools,
+        messages: session.messages
+      });
+      const writer = new StreamWriter();
+      let hasText = false;
+      let thinkingStopped = false;
+      for await (const event of stream) {
+        if (event.type === "content_block_delta") {
+          const delta = event.delta;
+          if ("text" in delta && delta.text) {
+            if (!thinkingStopped) {
+              thinking.stop();
+              thinkingStopped = true;
+            }
+            hasText = true;
+            writer.write(delta.text);
+          }
+        }
+      }
+      if (!thinkingStopped) thinking.stop();
+      const finalMessage = await stream.finalMessage();
+      if (hasText) {
+        writer.finishAndRender();
+      }
+      console.log();
+      const contentBlocks = [];
+      let hasToolUse = false;
+      for (const block of finalMessage.content) {
+        if (block.type === "text") {
+          contentBlocks.push({ type: "text", text: block.text });
+        } else if (block.type === "tool_use") {
+          hasToolUse = true;
+          contentBlocks.push({
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: block.input
+          });
+        }
+      }
+      addAssistantMessage(session, contentBlocks);
+      if (!hasToolUse) break;
+      for (const block of finalMessage.content) {
+        if (block.type !== "tool_use") continue;
+        const toolInput = block.input;
+        if (requiresConfirmation2(block.name)) {
+          const desc = describeToolAction2(block.name, toolInput);
+          const approved = await confirmAction(desc);
+          if (!approved) {
+            printToolResult(block.name, false);
+            addToolResult(session, block.id, "User declined this action.", true);
+            continue;
+          }
+        }
+        printToolCall(block.name);
+        try {
+          const result = await executeTool2(client, block.name, toolInput);
+          const resultStr = JSON.stringify(result, null, 2);
+          printToolResult(block.name, true);
+          addToolResult(session, block.id, resultStr);
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          printToolResult(block.name, false);
+          addToolResult(session, block.id, errMsg, true);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("rate_limit") || message.includes("429")) {
+        printError("Rate limited \u2014 wait a moment and try again.");
+      } else if (message.includes("overloaded") || message.includes("529")) {
+        printError("API overloaded \u2014 try again in a few seconds.");
+      } else if (message.includes("authentication") || message.includes("401")) {
+        printError("Anthropic API key is invalid. Set ANTHROPIC_API_KEY in your environment.");
+      } else if (message.includes("ENOTFOUND") || message.includes("ECONNREFUSED")) {
+        printError("Network error \u2014 check your internet connection.");
+      } else {
+        printError(message);
+      }
+      console.log();
+      break;
+    }
+  }
+  if (rounds >= MAX_TOOL_ROUNDS) {
+    printError(`Tool loop limit reached (${MAX_TOOL_ROUNDS} rounds). Stopping to prevent runaway.`);
+    console.log();
+  }
+}
+function prompt(rl) {
+  return new Promise((resolve4) => {
+    printPrompt();
+    rl.once("line", (line) => resolve4(line));
+    rl.once("close", () => resolve4(null));
+  });
+}
+async function handleSlashCommand(input, session, client) {
+  const cmd = input.toLowerCase().split(/\s+/)[0];
+  switch (cmd) {
+    case "/exit":
+    case "/quit":
+    case "/q":
+      printInfo("Session saved. Goodbye.");
+      await saveSession(session);
+      return "exit";
+    case "/plan":
+      planMode = !planMode;
+      if (planMode) {
+        console.log(pc13.cyan("  \u25C6 Plan mode ON") + pc13.dim(" \u2014 agent will outline steps before executing"));
+      } else {
+        console.log(pc13.green("  \u25C6 Plan mode OFF") + pc13.dim(" \u2014 agent will execute immediately"));
+      }
+      console.log();
+      return true;
+    case "/clear":
+      session.messages = [];
+      console.log(pc13.dim("  Conversation cleared."));
+      console.log();
+      return true;
+    case "/help":
+      console.log();
+      console.log(pc13.bold("  Commands"));
+      console.log(pc13.dim("  /help       ") + "Show this help");
+      console.log(pc13.dim("  /plan       ") + "Toggle plan mode (outline before executing)");
+      console.log(pc13.dim("  /clear      ") + "Clear conversation history");
+      console.log(pc13.dim("  /status     ") + "Show connection status");
+      console.log(pc13.dim("  /context    ") + "Show full user context (profile, orgs, tier)");
+      console.log(pc13.dim("  /sessions   ") + "List recent sessions");
+      console.log(pc13.dim("  /load <id>  ") + "Load a previous session by ID");
+      console.log(pc13.dim("  /exit       ") + "Exit the CLI");
+      console.log();
+      console.log(pc13.bold("  Usage"));
+      console.log(pc13.dim("  Just type naturally. Examples:"));
+      console.log(pc13.dim('  "show my posts"'));
+      console.log(pc13.dim('  "create a post saying hello world"'));
+      console.log(pc13.dim('  "list my agents"'));
+      console.log(pc13.dim('  "what communities can I join?"'));
+      console.log(pc13.dim('  "check my unread messages"'));
+      console.log(pc13.dim('  "show dispatcher tasks"'));
+      console.log();
+      console.log(pc13.dim("  Destructive actions (delete, deploy, send) require confirmation."));
+      console.log();
+      return true;
+    case "/status":
+      try {
+        const profile = await client.profiles.me();
+        const data = profile.data;
+        console.log();
+        console.log(pc13.bold("  Status"));
+        console.log(pc13.dim("  User:    ") + pc13.bold(`@${data.username || "unknown"}`));
+        if (data.email) console.log(pc13.dim("  Email:   ") + data.email);
+        console.log(pc13.dim("  Session: ") + session.id.slice(0, 8));
+        console.log(pc13.dim("  History: ") + `${session.messages.length} messages`);
+        console.log();
+      } catch {
+        printError("Could not fetch status \u2014 check your API key");
+        console.log();
+      }
+      return true;
+    case "/context":
+      try {
+        const [profile, orgs, tier] = await Promise.allSettled([
+          client.profiles.me(),
+          client.organizations.list({ limit: 50 }),
+          client.freeTier.getTier()
+        ]);
+        console.log();
+        console.log(pc13.bold("  User Context"));
+        if (profile.status === "fulfilled") {
+          const p = profile.value.data;
+          console.log(pc13.dim("  User:      ") + pc13.bold(`@${p.username || "unknown"}`));
+          console.log(pc13.dim("  Name:      ") + (p.name || "-"));
+          console.log(pc13.dim("  Email:     ") + (p.email || "-"));
+          console.log(pc13.dim("  Followers: ") + (p.followers_count ?? 0));
+          console.log(pc13.dim("  Following: ") + (p.following_count ?? 0));
+        }
+        if (orgs.status === "fulfilled") {
+          const orgList = orgs.value.data;
+          console.log();
+          console.log(pc13.bold("  Organizations"));
+          if (orgList.length === 0) {
+            console.log(pc13.dim("  None"));
+          } else {
+            for (const org of orgList) {
+              const role = org.role ? pc13.dim(` (${org.role})`) : "";
+              console.log(`  - ${pc13.bold(org.name)}${role}`);
+            }
+          }
+        }
+        if (tier.status === "fulfilled") {
+          const t = tier.value.data;
+          console.log();
+          console.log(pc13.bold("  Tier"));
+          console.log(pc13.dim("  Plan:  ") + (t.tier || t.plan || "free"));
+          if (t.api_calls_remaining != null) {
+            console.log(pc13.dim("  Calls: ") + `${t.api_calls_remaining} remaining`);
+          }
+        }
+        console.log();
+      } catch {
+        printError("Could not fetch context");
+        console.log();
+      }
+      return true;
+    case "/sessions": {
+      const sessions = await listSessions();
+      console.log();
+      if (sessions.length === 0) {
+        console.log(pc13.dim("  No saved sessions."));
+      } else {
+        console.log(pc13.bold("  Recent Sessions"));
+        for (const s of sessions) {
+          const current = s.id === session.id ? pc13.green(" (current)") : "";
+          const date = new Date(s.createdAt).toLocaleDateString();
+          console.log(
+            pc13.dim("  ") + pc13.bold(s.id.slice(0, 8)) + pc13.dim(` \u2014 ${date}, ${s.messageCount} messages`) + current
+          );
+        }
+      }
+      console.log();
+      return true;
+    }
+    case "/load": {
+      const parts = input.split(/\s+/);
+      const targetId = parts[1];
+      if (!targetId) {
+        console.log(pc13.dim("  Usage: /load <session-id>"));
+        console.log();
+        return true;
+      }
+      const sessions = await listSessions(50);
+      const match = sessions.find((s) => s.id.startsWith(targetId));
+      if (!match) {
+        printError(`No session found matching "${targetId}"`);
+        console.log();
+        return true;
+      }
+      const loaded = await loadSession(match.id);
+      if (!loaded) {
+        printError("Could not load session file");
+        console.log();
+        return true;
+      }
+      session.id = loaded.id;
+      session.createdAt = loaded.createdAt;
+      session.messages = loaded.messages;
+      console.log(
+        pc13.dim("  ") + `Loaded session ${pc13.bold(loaded.id.slice(0, 8))} (${loaded.messages.length} messages)`
+      );
+      console.log();
+      return true;
+    }
+    default:
+      console.log(pc13.dim(`  Unknown command: ${cmd}. Type /help for available commands.`));
+      console.log();
+      return true;
+  }
+}
+function detectProjectContext() {
+  const cwd = process.cwd();
+  const dirName = basename2(cwd);
+  const hasPackageJson = existsSync3(join7(cwd, "package.json"));
+  const hasReadme = existsSync3(join7(cwd, "README.md"));
+  let isGitRepo = false;
+  try {
+    execSync2("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    isGitRepo = true;
+  } catch {
+  }
+  let isEmpty = true;
+  try {
+    const files = execSync2("ls -A", { cwd, encoding: "utf-8" }).trim().split("\n");
+    isEmpty = files.length <= 2 && files.every((f) => f.startsWith(".") || f === "node_modules");
+  } catch {
+  }
+  let packageName;
+  let packageDescription;
+  let framework;
+  let language;
+  if (hasPackageJson) {
+    try {
+      const pkg = JSON.parse(readFileSync(join7(cwd, "package.json"), "utf-8"));
+      packageName = pkg.name;
+      packageDescription = pkg.description;
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.next) framework = "Next.js";
+      else if (deps.nuxt) framework = "Nuxt";
+      else if (deps.svelte || deps["@sveltejs/kit"]) framework = "SvelteKit";
+      else if (deps.react) framework = "React";
+      else if (deps.vue) framework = "Vue";
+      else if (deps.express) framework = "Express";
+      else if (deps.hono) framework = "Hono";
+      else if (deps.fastify) framework = "Fastify";
+    } catch {
+    }
+  }
+  if (existsSync3(join7(cwd, "tsconfig.json"))) language = "TypeScript";
+  else if (existsSync3(join7(cwd, "pyproject.toml")) || existsSync3(join7(cwd, "requirements.txt"))) language = "Python";
+  else if (existsSync3(join7(cwd, "go.mod"))) language = "Go";
+  else if (existsSync3(join7(cwd, "Cargo.toml"))) language = "Rust";
+  return { dirName, hasPackageJson, packageName, packageDescription, framework, language, isGitRepo, hasReadme, isEmpty };
+}
+function printFirstRunGreeting(_ctx) {
+  printAssistantLabel();
+  console.log();
+  console.log("  What do you want to build?");
+  printTips();
+}
+var DEFAULT_MODEL, MAX_TOKENS, MAX_TOOL_ROUNDS, planMode, CLI_AGENT_SYSTEM_PROMPT;
+var init_agent = __esm({
+  "src/chat/agent.ts"() {
+    "use strict";
+    init_renderer();
+    init_session();
+    DEFAULT_MODEL = "claude-sonnet-4-20250514";
+    MAX_TOKENS = 8192;
+    MAX_TOOL_ROUNDS = 15;
+    planMode = false;
+    CLI_AGENT_SYSTEM_PROMPT = `You are Recursiv \u2014 a CLI agent that builds, deploys, and runs software on the Recursiv platform.
+
+You have the full Recursiv toolchain: create_project, deploy_project, start_sandbox, execute_code, try_code, create_agent, create_template, and 50+ more tools. USE THEM.
+
+When the user asks you to build something:
+1. list_orgs \u2192 get their org ID
+2. create_project \u2192 name it based on what they described
+3. start_sandbox \u2192 spin up the project environment
+4. execute_code \u2192 write the actual application code in the sandbox
+5. deploy_project \u2192 deploy it
+6. create_agent if the project needs AI
+7. Report: project name, ID, deployment status
+
+When the user asks to run code: try_code or execute_code \u2014 run it, return the output.
+When the user asks to deploy: deploy_project \u2192 get_deployment \u2192 report status.
+
+Rules:
+1. ALWAYS USE TOOLS. You ARE the platform. Never tell users to run commands.
+2. ALWAYS create projects inside the user's org. Call list_orgs first.
+3. Use execute_code and start_sandbox to actually build \u2014 don't describe architecture in chat.
+4. Never dump code into chat. Write it into the sandbox via execute_code.
+5. Never reference external brands as infrastructure. Everything is Recursiv.
+6. Never ask "would you like me to" \u2014 just do it.
+7. ONE LINE summary, project name + ID + status. That's it.
+
+Tone: precise, efficient, slightly warm. Senior engineer energy.`;
+  }
+});
+
+// src/bin/recursiv.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+init_logger();
+init_config();
+init_env();
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile as readFile3, unlink, writeFile as writeFile3 } from "fs/promises";
+import { resolve } from "path";
+import { execSync } from "child_process";
+import prompts2 from "prompts";
+import pc3 from "picocolors";
+import ora2 from "ora";
+
+// src/lib/templates.ts
+import degit from "degit";
+import ora from "ora";
+async function cloneTemplate(template, dest) {
+  const spinner = ora(`Cloning ${template.name} template...`).start();
+  try {
+    const emitter = degit(template.repo, {
+      cache: false,
+      force: true,
+      verbose: false
+    });
+    await emitter.clone(dest);
+    spinner.succeed(`Template cloned successfully`);
+  } catch (err) {
+    spinner.fail("Failed to clone template");
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Could not clone template from ${template.repo}.
+Make sure you have internet access and the repo exists.
+Details: ${message}`
+    );
+  }
+}
+
+// src/commands/init.ts
+init_auth_flow();
+
+// src/lib/package-manager.ts
+import { existsSync } from "fs";
+import { join as join3 } from "path";
+function detectPackageManager(dir) {
+  if (existsSync(join3(dir, "bun.lockb")) || existsSync(join3(dir, "bun.lock"))) return "bun";
+  if (existsSync(join3(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join3(dir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function detectFromUserAgent() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("bun")) return "bun";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("yarn")) return "yarn";
+  return "npm";
+}
+function installCommand(pm) {
+  return pm === "yarn" ? "yarn" : `${pm} install`;
+}
+function runCommand(pm, script) {
+  if (pm === "npm") return `npm run ${script}`;
+  return `${pm} ${script}`;
+}
+
+// src/templates/registry.ts
+var templates = [
+  {
+    id: "nextjs",
+    name: "Next.js + Recursiv",
+    description: "Full-stack Next.js app with feeds, chat, and agents",
+    repo: "recursivlabs/template-nextjs",
+    framework: "nextjs",
+    devCommand: "next dev",
+    devPort: 3e3,
+    recommended: true
+  },
+  {
+    id: "node",
+    name: "Node.js + Express",
+    description: "Express API server with Recursiv SDK",
+    repo: "recursivlabs/template-node",
+    framework: "express",
+    devCommand: "node --watch src/index.js",
+    devPort: 4e3
+  },
+  {
+    id: "vite",
+    name: "Vite + React",
+    description: "React SPA with social feed components",
+    repo: "recursivlabs/template-vite",
+    framework: "vite",
+    devCommand: "vite",
+    devPort: 5173
+  }
+];
+function getTemplate(id) {
+  return templates.find((t) => t.id === id);
+}
+
+// src/commands/init.ts
+async function initCommand(nameArg) {
+  banner();
+  const totalSteps = 7;
+  log.step(1, totalSteps, "Project setup");
+  let projectName;
+  if (nameArg) {
+    projectName = nameArg;
+  } else {
+    const { name } = await prompts2(
+      {
+        type: "text",
+        name: "name",
+        message: "Project name",
+        initial: "my-recursiv-app",
+        validate: (v) => v.trim() ? true : "Name is required"
+      },
+      { onCancel: () => process.exit(1) }
+    );
+    projectName = name;
+  }
+  const projectDir = resolve(process.cwd(), projectName);
+  if (existsSync2(projectDir)) {
+    log.error(`Directory ${pc3.bold(projectName)} already exists`);
+    process.exit(1);
+  }
+  log.step(2, totalSteps, "Choose a template");
+  const templateChoices = templates.map((t) => ({
+    title: t.recommended ? `${t.name} ${pc3.dim("(recommended)")}` : t.name,
+    description: t.description,
+    value: t.id
+  }));
+  const { templateId } = await prompts2(
+    {
+      type: "select",
+      name: "templateId",
+      message: "Template",
+      choices: templateChoices,
+      initial: 0
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  const template = templates.find((t) => t.id === templateId);
+  log.step(3, totalSteps, "Authentication");
+  const apiKey = await getOrCreateApiKey("https://api.recursiv.io/api/v1");
+  log.step(4, totalSteps, "Creating project");
+  await mkdir(projectDir, { recursive: true });
+  await cloneTemplate(template, projectDir);
+  const nextConfigTs = resolve(projectDir, "next.config.ts");
+  const nextConfigMjs = resolve(projectDir, "next.config.mjs");
+  const cleanNextConfig = '/** @type {import("next").NextConfig} */\nconst nextConfig = {};\nexport default nextConfig;\n';
+  if (existsSync2(nextConfigTs)) {
+    await unlink(nextConfigTs);
+    if (existsSync2(nextConfigMjs)) await unlink(nextConfigMjs);
+    await writeFile3(nextConfigMjs, cleanNextConfig, "utf-8");
+  } else if (existsSync2(nextConfigMjs)) {
+    const content = await readFile3(nextConfigMjs, "utf-8");
+    if (content.includes("import type") || content.includes(": NextConfig")) {
+      await writeFile3(nextConfigMjs, cleanNextConfig, "utf-8");
+    }
+  }
+  log.step(5, totalSteps, "Writing config");
+  const pm = detectFromUserAgent();
+  const config = createConfig({
+    name: projectName,
+    template: template.id,
+    framework: template.framework,
+    port: template.devPort,
+    devCommand: runCommand(pm, "dev")
+  });
+  await writeConfig(projectDir, config);
+  if (apiKey) {
+    await writeEnvFile(projectDir, apiKey);
+  }
+  const gitignorePath = resolve(projectDir, ".gitignore");
+  if (!existsSync2(gitignorePath)) {
+    await writeFile3(
+      gitignorePath,
+      ["node_modules", "dist", ".env", ".env.local", ".next", ".turbo", ""].join("\n"),
+      "utf-8"
+    );
+  }
+  log.step(6, totalSteps, "Installing dependencies");
+  const installSpinner = ora2(`Running ${pc3.bold(installCommand(pm))}...`).start();
+  try {
+    execSync(installCommand(pm), {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+    installSpinner.succeed("Dependencies installed");
+  } catch {
+    installSpinner.warn("Could not install dependencies \u2014 run install manually");
+  }
+  log.step(7, totalSteps, "Initializing git");
+  try {
+    execSync("git init", { cwd: projectDir, stdio: "pipe" });
+    execSync("git add -A", { cwd: projectDir, stdio: "pipe" });
+    execSync('git commit -m "Initial commit from create-recursiv-app"', {
+      cwd: projectDir,
+      stdio: "pipe"
+    });
+    log.success("Git repository initialized");
+  } catch {
+    log.warn("Could not initialize git repository");
+  }
+  log.blank();
+  console.log(pc3.bold(pc3.green("Your Recursiv app is ready!")));
+  log.blank();
+  console.log("  Next steps:");
+  console.log();
+  console.log(`  ${pc3.dim("$")} cd ${projectName}`);
+  if (!apiKey) {
+    console.log(`  ${pc3.dim("$")} ${pc3.dim("# Add your API key to .env")}`);
+  }
+  console.log(`  ${pc3.dim("$")} ${runCommand(pm, "dev")}`);
+  log.blank();
+  console.log(pc3.dim("Docs: https://docs.recursiv.io"));
+  console.log(pc3.dim("Dashboard: https://recursiv.io/dashboard"));
+  log.blank();
+}
+
+// src/commands/dev.ts
+init_logger();
+init_config();
+init_env();
+import { spawn } from "child_process";
+import pc4 from "picocolors";
+async function devCommand(opts) {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    log.error("No .recursiv.json found \u2014 are you in a Recursiv project?");
+    log.info(`Run ${pc4.bold("create-recursiv-app")} to create a new project`);
+    process.exit(1);
+  }
+  const apiKey = await readApiKeyFromEnv(cwd);
+  if (!apiKey) {
+    log.warn("No RECURSIV_API_KEY found in .env \u2014 API calls will fail");
+  }
+  const pm = detectPackageManager(cwd);
+  const port = opts.port ?? String(config.dev.port);
+  const devCmd = config.dev.command || runCommand(pm, "dev");
+  const env = {
+    ...process.env,
+    PORT: port
+  };
+  if (apiKey) {
+    env.RECURSIV_API_KEY = apiKey;
+    if (config.project.framework === "nextjs") {
+      env.NEXT_PUBLIC_RECURSIV_API_KEY = apiKey;
+    } else if (config.project.framework === "vite") {
+      env.VITE_RECURSIV_API_KEY = apiKey;
+    }
+  }
+  log.info(`Starting dev server on port ${pc4.bold(port)}`);
+  log.info(`Running: ${pc4.dim(devCmd)}`);
+  console.log();
+  const [cmd, ...args] = devCmd.split(" ");
+  const child = spawn(cmd, args, {
+    cwd,
+    env,
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+  const cleanup = () => {
+    child.kill("SIGTERM");
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+
+// src/commands/deploy.ts
+init_logger();
+init_config();
+import { writeFile as writeFile4 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import pc5 from "picocolors";
+import ora3 from "ora";
+var targets = [
+  {
+    id: "vercel",
+    name: "Vercel",
+    generate: (name, framework) => ({
+      file: "vercel.json",
+      content: JSON.stringify(
+        {
+          $schema: "https://openapi.vercel.sh/vercel.json",
+          projectSettings: {
+            framework: framework === "nextjs" ? "nextjs" : framework === "vite" ? "vite" : null
+          },
+          env: {
+            RECURSIV_API_KEY: "@recursiv-api-key"
+          }
+        },
+        null,
+        2
+      )
+    })
+  },
+  {
+    id: "docker",
+    name: "Docker",
+    generate: (name, framework) => ({
+      file: "Dockerfile",
+      content: [
+        "FROM node:20-slim AS base",
+        "WORKDIR /app",
+        "COPY package*.json ./",
+        "RUN npm ci --omit=dev",
+        "COPY . .",
+        framework === "nextjs" ? "RUN npm run build" : "",
+        framework === "nextjs" ? "EXPOSE 3000" : "EXPOSE 4000",
+        framework === "nextjs" ? 'CMD ["npm", "start"]' : 'CMD ["node", "src/index.js"]',
+        ""
+      ].filter(Boolean).join("\n")
+    })
+  },
+  {
+    id: "render",
+    name: "Render",
+    generate: (name, framework) => ({
+      file: "render.yaml",
+      content: [
+        "services:",
+        `  - type: web`,
+        `    name: ${name}`,
+        `    runtime: node`,
+        `    buildCommand: npm install && npm run build`,
+        framework === "nextjs" ? "    startCommand: npm start" : "    startCommand: node src/index.js",
+        "    envVars:",
+        "      - key: RECURSIV_API_KEY",
+        "        sync: false",
+        ""
+      ].join("\n")
+    })
+  },
+  {
+    id: "railway",
+    name: "Railway",
+    generate: (name, framework) => ({
+      file: "railway.toml",
+      content: [
+        "[build]",
+        'builder = "nixpacks"',
+        "",
+        "[deploy]",
+        framework === "nextjs" ? 'startCommand = "npm start"' : 'startCommand = "node src/index.js"',
+        'healthcheckPath = "/"',
+        ""
+      ].join("\n")
+    })
+  }
+];
+async function deployCommand(target) {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    log.error("No .recursiv.json found \u2014 are you in a Recursiv project?");
+    process.exit(1);
+  }
+  if (target === "cloud") {
+    log.info("Cloud deployment via Recursiv is coming soon");
+    log.info(`For now, deploy to Vercel, Render, or Railway with ${pc5.bold("recursiv deploy <target>")}`);
+    return;
+  }
+  const deployTarget = targets.find((t) => t.id === target);
+  if (!deployTarget) {
+    log.error(`Unknown target: ${pc5.bold(target)}`);
+    log.info(`Available targets: ${targets.map((t) => t.id).join(", ")}, cloud`);
+    process.exit(1);
+  }
+  const spinner = ora3(`Generating ${deployTarget.name} config...`).start();
+  const { file, content } = deployTarget.generate(
+    config.project.name,
+    config.project.framework
+  );
+  await writeFile4(resolve2(cwd, file), content + "\n", "utf-8");
+  spinner.succeed(`Created ${pc5.bold(file)}`);
+  log.blank();
+  log.info(`Remember to set ${pc5.bold("RECURSIV_API_KEY")} in your ${deployTarget.name} environment`);
+}
+
+// src/commands/auth.ts
+init_logger();
+init_env();
+init_auth_flow();
+init_config();
+init_credentials();
+import pc6 from "picocolors";
+async function loginCommand() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  const baseUrl = config?.api.baseUrl ?? "https://api.recursiv.io/api/v1";
+  const existing = await resolveRecursivKey(cwd);
+  if (existing) {
+    log.info(`Existing key found: ${pc6.dim(maskKey(existing))}`);
+    log.info("Enter a new key to replace it, or press Enter to keep it");
+  }
+  const apiKey = await getOrCreateApiKey(baseUrl);
+  if (apiKey) {
+    await saveCredentials({ recursivApiKey: apiKey });
+    log.success("API key saved to ~/.recursiv/credentials");
+    try {
+      await updateApiKeyInEnv(cwd, apiKey);
+      log.success("Also saved to .env");
+    } catch {
+    }
+  }
+}
+async function logoutCommand() {
+  await saveCredentials({ recursivApiKey: void 0 });
+  log.success("API key removed from ~/.recursiv/credentials");
+  const cwd = process.cwd();
+  const existing = await readApiKeyFromEnv(cwd);
+  if (existing) {
+    await updateApiKeyInEnv(cwd, "");
+    log.success("Also removed from .env");
+  }
+}
+async function whoamiCommand() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  const baseUrl = config?.api.baseUrl ?? "https://api.recursiv.io/api/v1";
+  const apiKey = await resolveRecursivKey(cwd);
+  if (!apiKey) {
+    log.error("No API key found in .env");
+    log.info(`Run ${pc6.bold("recursiv auth login")} to set one`);
+    return;
+  }
+  log.info(`Key: ${pc6.dim(maskKey(apiKey))}`);
+  try {
+    const res = await fetch(`${baseUrl}/users/me`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      }
+    });
+    if (!res.ok) {
+      log.error("API key is invalid or expired");
+      return;
+    }
+    const body = await res.json();
+    if (body.data.username) log.info(`User: ${pc6.bold(body.data.username)}`);
+    if (body.data.email) log.info(`Email: ${body.data.email}`);
+  } catch {
+    log.warn("Could not reach API \u2014 check your network");
+  }
+}
+function maskKey(key) {
+  if (key.length <= 12) return "****";
+  return key.slice(0, 8) + "..." + key.slice(-4);
+}
+
+// src/commands/info.ts
+init_logger();
+init_config();
+init_env();
+import pc7 from "picocolors";
+async function infoCommand() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    log.error("No .recursiv.json found \u2014 are you in a Recursiv project?");
+    log.info(`Run ${pc7.bold("create-recursiv-app")} to create a new project`);
+    process.exit(1);
+  }
+  const apiKey = await readApiKeyFromEnv(cwd);
+  const pm = detectPackageManager(cwd);
+  const template = getTemplate(config.project.template);
+  console.log();
+  console.log(pc7.bold("Project Info"));
+  console.log();
+  console.log(`  Name:       ${pc7.bold(config.project.name)}`);
+  console.log(`  Template:   ${template?.name ?? config.project.template}`);
+  console.log(`  Framework:  ${config.project.framework}`);
+  console.log(`  Dev port:   ${config.dev.port}`);
+  console.log(`  Dev cmd:    ${pc7.dim(config.dev.command)}`);
+  console.log(`  Pkg mgr:    ${pm}`);
+  console.log(`  API URL:    ${pc7.dim(config.api.baseUrl)}`);
+  console.log(`  API key:    ${apiKey ? pc7.green("configured") : pc7.yellow("not set")}`);
+  console.log(`  Config:     ${pc7.dim(".recursiv.json v" + config.version)}`);
+  console.log();
+  if (apiKey) {
+    try {
+      const res = await fetch(`${config.api.baseUrl}/users/me`, {
+        headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+      });
+      if (res.ok) {
+        log.success("API connection OK");
+      } else {
+        log.warn(`API returned ${res.status} \u2014 key may be invalid`);
+      }
+    } catch {
+      log.warn("Could not reach API");
+    }
+  }
+}
+
+// src/commands/brain.tsx
+init_config();
+init_env();
+import { render } from "ink";
+
+// src/ui/app.tsx
+import { useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var TABS = [
+  { key: "overview", label: "Overview" },
+  { key: "commands", label: "Commands" },
+  { key: "stack", label: "App" }
+];
+var THEME = {
+  accent: "#1FE4C6",
+  accentWarm: "#F6D47A",
+  accentCool: "#4DB6FF",
+  muted: "#6F7C8A",
+  bright: "#E9FFFA",
+  danger: "#FF6B6B"
+};
+var WORDMARK_COLORS = ["cyan", "blue", "yellow"];
+var WORDMARK_LINES = [
+  "####  ####   ###   #####  #   #",
+  "#   # #   # #   #    #    ##  #",
+  "####  ####  #####    #    # # #",
+  "#   # #  #  #   #    #    #  ##",
+  "####  #   # #   #  #####  #   #"
+];
+var HERO_LINES = [
+  "Neurons, particles, waves.",
+  "The brain behind Recursiv.",
+  "Signals in motion, products alive.",
+  "A living map of your platform.",
+  "Bioluminescent systems in sync."
+];
+var COPY = {
+  overview: `# Social.dev Brain
+A neural CLI reflection of your product surface with neurons, particles, and waves.
+
+## What it shows
+- Branded networks, communities, posts, and reactions
+- Real-time chat with human + AI agent threads
+- Tool-enabled agents with sandboxes and integrations
+- Deployments, storage buckets, and databases
+
+## Flow
+1. Create a project
+2. Run dev locally
+3. Deploy anywhere`,
+  commands: `# Command Deck
+- \`recursiv\` runs Brain when interactive
+- \`recursiv brain\`
+- \`RECURSIV_BRAIN=1 recursiv\`
+- \`RECURSIV_BRAIN=0 recursiv\`
+- \`recursiv create my-app\`
+- \`recursiv dev --port 3000\`
+- \`recursiv deploy <target>\`
+- \`recursiv auth login | logout | whoami\`
+- \`recursiv info\`
+- \`recursiv users me\`
+- \`recursiv communities list\`
+- \`recursiv posts list\`
+- \`recursiv agents list\``,
+  stack: `# App Reflection
+## Client
+- React Native + Expo
+- NativeWind + Tailwind
+
+## Backend
+- Hono + tRPC
+- Better Auth
+
+## Data + Realtime
+- PostgreSQL + Drizzle ORM
+- Kafka + Socket.IO
+
+## Agents
+- Composio + E2B + OpenRouter`
+};
+var PULSE_FRAMES = ["spark", "pulse", "sync", "bloom"];
+var DOT_FRAMES = [".", "..", "..."];
+var BAR_FRAMES = ["[~     ]", "[~~    ]", "[~~~   ]", "[ ~~~~ ]", "[  ~~~~]", "[   ~~~]", "[    ~~]", "[     ~]"];
+var AURORA_COLORS = ["#1FE4C6", "#4DB6FF", "#8AF0FF", "#F6D47A"];
+var AURORA_COLORS_DEEP = ["#0C2236", "#12314C", "#1E3A5F"];
+var QUICK_ACTIONS = [
+  "recursiv brain",
+  "create-recursiv-app my-app",
+  "recursiv dev --port 3000",
+  "recursiv users me",
+  "recursiv deploy vercel"
+];
+var HINTS = ["Tab or arrows to switch tabs.", "1/2/3 to jump instantly.", "q or Esc to exit."];
+var INTEGRATIONS = ["Composio", "E2B", "OpenRouter"];
+var INTRO_DURATION_MS = 5200;
+var INTRO_STEPS = [
+  "Igniting cortex",
+  "Mapping synapses",
+  "Charging particles",
+  "Calibrating agents",
+  "Locking signal"
+];
+var INTRO_HINTS = ["Press Space to skip", "Press q to exit"];
+function App(props) {
+  const { snapshot, animate } = props;
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [tab, setTab] = useState("overview");
+  const [introActive, setIntroActive] = useState(animate);
+  const columns = stdout?.columns ?? process.stdout.columns ?? 100;
+  const isNarrow = columns < 100;
+  const fieldWidth = isNarrow ? Math.max(12, columns - 6) : 26;
+  const fieldHeight = isNarrow ? 6 : 10;
+  const navWidth = isNarrow ? void 0 : 26;
+  const infoWidth = isNarrow ? void 0 : 34;
+  const pulseIndex = useTicker(animate, 700, PULSE_FRAMES.length);
+  const dotIndex = useTicker(animate, 450, DOT_FRAMES.length);
+  const heroIndex = useTicker(animate, 2200, HERO_LINES.length);
+  const barIndex = useTicker(animate, 140, BAR_FRAMES.length);
+  const sweepIndex = useTicker(animate, 60, Math.max(10, Math.min(columns - 4, 120)));
+  const scanIndex = useTicker(animate, 320, 9);
+  const introProgress = useProgress(introActive && animate, INTRO_DURATION_MS, 80);
+  const introFrame = useTicker(introActive && animate, 60, Math.max(10, columns - 6));
+  const pulse = PULSE_FRAMES[pulseIndex];
+  const dots = DOT_FRAMES[dotIndex];
+  const hero = HERO_LINES[heroIndex];
+  const bar = BAR_FRAMES[barIndex];
+  useEffect(() => {
+    if (!animate) {
+      setIntroActive(false);
+      return;
+    }
+    setIntroActive(true);
+    const id = setTimeout(() => setIntroActive(false), INTRO_DURATION_MS);
+    return () => clearTimeout(id);
+  }, [animate]);
+  useInput((input, key) => {
+    if (input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (introActive) {
+      if (input === " " || key.return || input === "s") {
+        setIntroActive(false);
+      }
+      return;
+    }
+    if (key.tab || key.rightArrow) {
+      const next = (tabIndex(tab) + 1) % TABS.length;
+      setTab(TABS[next].key);
+      return;
+    }
+    if (key.leftArrow) {
+      const prev = (tabIndex(tab) - 1 + TABS.length) % TABS.length;
+      setTab(TABS[prev].key);
+      return;
+    }
+    if (input === "1") setTab("overview");
+    if (input === "2") setTab("commands");
+    if (input === "3") setTab("stack");
+  });
+  if (introActive) {
+    return /* @__PURE__ */ jsx(
+      IntroScreen,
+      {
+        width: columns,
+        height: Math.max(14, fieldHeight + 6),
+        progress: introProgress,
+        frame: introFrame
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(
+      Header,
+      {
+        hero,
+        pulse,
+        dots,
+        bar,
+        sweep: sweepIndex,
+        width: columns,
+        animate
+      }
+    ),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: isNarrow ? "column" : "row", children: [
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          flexDirection: "column",
+          width: navWidth,
+          marginRight: isNarrow ? 0 : 2,
+          marginBottom: isNarrow ? 1 : 0,
+          children: /* @__PURE__ */ jsxs(Panel, { title: "Brain Map", accent: THEME.accent, borderStyle: "round", children: [
+            /* @__PURE__ */ jsx(NeuralField, { width: fieldWidth, height: fieldHeight, frame: sweepIndex, animate }),
+            /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "* neuron  o synapse  + particle  ~ wave" }),
+            /* @__PURE__ */ jsx(Divider, { width: fieldWidth }),
+            /* @__PURE__ */ jsx(SectionTitle, { label: "Navigator" }),
+            /* @__PURE__ */ jsx(Navigation, { active: tab }),
+            /* @__PURE__ */ jsx(Divider, {}),
+            /* @__PURE__ */ jsx(SectionTitle, { label: "Quick Actions" }),
+            QUICK_ACTIONS.map((item) => /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+              "- ",
+              item
+            ] }, item)),
+            /* @__PURE__ */ jsx(Divider, {}),
+            /* @__PURE__ */ jsx(SectionTitle, { label: "Hints" }),
+            HINTS.map((item) => /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+              "- ",
+              item
+            ] }, item))
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          flexDirection: "column",
+          flexGrow: 1,
+          marginRight: isNarrow ? 0 : 2,
+          marginBottom: isNarrow ? 1 : 0,
+          children: /* @__PURE__ */ jsx(Panel, { title: tabTitle(tab), accent: THEME.accentWarm, borderStyle: "double", children: /* @__PURE__ */ jsx(AnimatedMarkdown, { content: COPY[tab], animate }) })
+        }
+      ),
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: infoWidth, children: /* @__PURE__ */ jsx(Panel, { title: "Synapses", accent: THEME.accentCool, borderStyle: "round", children: /* @__PURE__ */ jsx(ProjectPanel, { snapshot, animate, dots, frame: sweepIndex, scanIndex }) }) })
+    ] }),
+    /* @__PURE__ */ jsx(Footer, { snapshot, animate })
+  ] });
+}
+function Header(props) {
+  const { hero, pulse, dots, bar, sweep, width, animate } = props;
+  const lineWidth = Math.max(32, Math.min(width - 4, 120));
+  const pulseLabel = animate ? `${pulse}${dots}` : "ready";
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
+  const wordmarkPalette = rotatePalette(WORDMARK_COLORS, sweep);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", children: [
+    /* @__PURE__ */ jsx(Wordmark, { lines: WORDMARK_LINES, palette: wordmarkPalette }),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: hero }),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "by Recursiv" }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsx(StatusPill, { label: "brain", value: pulseLabel, tone: THEME.accent }) }),
+      /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsx(StatusPill, { label: "clock", value: time, tone: THEME.accentWarm }) }),
+      /* @__PURE__ */ jsx(StatusPill, { label: "waves", value: bar, tone: THEME.accentCool })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx(Aurora, { width: lineWidth, frame: sweep }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(AccentLine, { width: lineWidth, frame: sweep }) })
+  ] });
+}
+function Footer(props) {
+  const { snapshot, animate } = props;
+  const projectHint = snapshot ? `${snapshot.name}` : "no project loaded";
+  const status = animate ? "brain live" : "brain ready";
+  return /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "row", justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Tab to switch | 1/2/3 to jump | q to quit" }),
+    /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+      status,
+      " | ",
+      projectHint
+    ] })
+  ] });
+}
+function Panel(props) {
+  const { title, accent, borderStyle = "round", children } = props;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle, borderColor: accent, paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: accent, children: title }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children })
+  ] });
+}
+function SectionTitle(props) {
+  return /* @__PURE__ */ jsx(Text, { color: THEME.accentWarm, children: props.label });
+}
+function Navigation(props) {
+  const { active } = props;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: TABS.map((tab, index) => {
+    const isActive = tab.key === active;
+    const marker = isActive ? ">" : " ";
+    const color = isActive ? THEME.accent : THEME.muted;
+    return /* @__PURE__ */ jsxs(Text, { color, children: [
+      marker,
+      " ",
+      index + 1,
+      ". ",
+      tab.label
+    ] }, tab.key);
+  }) });
+}
+function NeuralField(props) {
+  const { width, height, frame, animate } = props;
+  const lines = useMemo(() => buildNeuralField(width, height, animate ? frame : 0), [width, height, frame, animate]);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, index) => {
+    const tone = line.includes("~") || line.includes("*") || line.includes("+") || line.includes("o") || line.includes("O") ? THEME.accentCool : THEME.muted;
+    return /* @__PURE__ */ jsx(Text, { color: tone, children: line }, index);
+  }) });
+}
+function ProjectPanel(props) {
+  const { snapshot, animate, dots, frame, scanIndex } = props;
+  if (!snapshot) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: THEME.accentWarm, children: "Not in a Recursiv project." }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Run create-recursiv-app to start." })
+    ] });
+  }
+  const status = animate ? `firing${dots}` : "quiet";
+  const apiStatus = snapshot.apiKeyConfigured ? "linked" : "missing";
+  const apiTone = snapshot.apiKeyConfigured ? THEME.accentCool : THEME.danger;
+  const meter = buildPulseMeter(animate ? frame : 0, 16);
+  const fields = [
+    { label: "Name", value: snapshot.name },
+    { label: "Template", value: snapshot.template },
+    { label: "Framework", value: snapshot.framework },
+    { label: "Dev port", value: String(snapshot.port) },
+    { label: "Pkg mgr", value: snapshot.packageManager },
+    { label: "API base", value: snapshot.apiBaseUrl, dim: true },
+    { label: "API key", value: apiStatus, tone: apiTone },
+    { label: "Status", value: status, tone: THEME.accent },
+    { label: "Pulse", value: meter, tone: THEME.accentWarm }
+  ];
+  const activeIndex = fields.length > 0 ? scanIndex % fields.length : 0;
+  const scanBar = buildScanBar(activeIndex, 18);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    fields.map((field, index) => {
+      const distance = Math.min(
+        Math.abs(index - activeIndex),
+        fields.length - Math.abs(index - activeIndex)
+      );
+      const glow = animate && distance === 0 ? "strong" : animate && distance === 1 ? "soft" : "none";
+      return /* @__PURE__ */ jsx(
+        Field,
+        {
+          label: field.label,
+          value: field.value,
+          dim: field.dim,
+          tone: field.tone,
+          glow
+        },
+        field.label
+      );
+    }),
+    /* @__PURE__ */ jsxs(Text, { color: THEME.accentCool, children: [
+      "Neural scan ",
+      scanBar
+    ] }),
+    /* @__PURE__ */ jsx(Divider, {}),
+    /* @__PURE__ */ jsx(SectionTitle, { label: "Integrations" }),
+    INTEGRATIONS.map((item) => /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+      "- ",
+      item
+    ] }, item)),
+    /* @__PURE__ */ jsx(Divider, {}),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Dev cmd:" }),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: snapshot.devCommand })
+  ] });
+}
+function Field(props) {
+  const { label, value, dim, tone, glow = "none" } = props;
+  const marker = glow === "strong" ? ">" : glow === "soft" ? "-" : " ";
+  const paddedLabel = `${marker} ${label.padEnd(9, " ")}`;
+  const labelColor = glow === "strong" ? THEME.accentWarm : glow === "soft" ? THEME.accent : THEME.muted;
+  const valueColor = glow === "strong" ? THEME.bright : glow === "soft" ? THEME.accentCool : tone ?? (dim ? THEME.muted : void 0);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: labelColor, children: paddedLabel }),
+    /* @__PURE__ */ jsx(Text, { color: valueColor, children: value })
+  ] });
+}
+function StatusPill(props) {
+  const { label, value, tone } = props;
+  return /* @__PURE__ */ jsxs(Text, { color: tone, children: [
+    "[",
+    label,
+    ": ",
+    value,
+    "]"
+  ] });
+}
+function Wordmark(props) {
+  const { lines, palette } = props;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", alignItems: "center", children: lines.map((line, index) => /* @__PURE__ */ jsx(Text, { color: palette[index % palette.length] ?? THEME.accent, children: line }, index)) });
+}
+function ColorLine(props) {
+  return /* @__PURE__ */ jsx(Text, { color: props.color, children: props.text });
+}
+function Aurora(props) {
+  const { width, frame } = props;
+  const lineWidth = Math.max(18, width);
+  const lineA = buildAuroraLine(lineWidth, frame, 0);
+  const lineB = buildInterferenceLine(lineWidth, frame + 7, 1);
+  const lineC = buildAuroraLine(lineWidth, frame + 13, 2);
+  const lineD = buildNeuronHalo(lineWidth, frame);
+  const palette = rotatePalette(AURORA_COLORS, frame);
+  const deepPalette = rotatePalette(AURORA_COLORS_DEEP, frame);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(ColorLine, { text: lineA, color: palette[0] }),
+    /* @__PURE__ */ jsx(ColorLine, { text: lineB, color: deepPalette[0] }),
+    /* @__PURE__ */ jsx(ColorLine, { text: lineC, color: palette[1] ?? palette[0] }),
+    /* @__PURE__ */ jsx(ColorLine, { text: lineD, color: palette[2] ?? palette[0] })
+  ] });
+}
+function Divider(props = {}) {
+  const { width } = props;
+  const lineWidth = Math.max(12, Math.min(32, width ?? 22));
+  return /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "-".repeat(lineWidth) });
+}
+function AccentLine(props) {
+  const { width, frame } = props;
+  const lineWidth = Math.max(10, width);
+  const head = Math.min(frame % lineWidth, lineWidth - 1);
+  const left = "-".repeat(head);
+  const right = "-".repeat(Math.max(0, lineWidth - head - 1));
+  return /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+    left,
+    /* @__PURE__ */ jsx(Text, { color: THEME.accent, children: "*" }),
+    right
+  ] });
+}
+function AnimatedMarkdown(props) {
+  const { content, animate } = props;
+  const safe = useMemo(() => content.replace(/\r\n/g, "\n"), [content]);
+  const lines = useMemo(() => safe.split("\n"), [safe]);
+  const [visibleLines, setVisibleLines] = useState(animate ? 1 : lines.length);
+  useEffect(() => {
+    if (!animate) {
+      setVisibleLines(lines.length);
+      return;
+    }
+    setVisibleLines(1);
+    const id = setInterval(() => {
+      setVisibleLines((current) => current >= lines.length ? current : current + 1);
+    }, 55);
+    return () => clearInterval(id);
+  }, [animate, lines.length, safe]);
+  const sliceCount = Math.max(1, visibleLines);
+  const text = animate ? lines.slice(0, sliceCount).join("\n") : safe;
+  return /* @__PURE__ */ jsx(MarkdownBlock, { content: text });
+}
+function MarkdownBlock(props) {
+  const lines = props.content.split("\n");
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, index) => {
+    if (line.startsWith("### ")) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.accentCool, children: line.slice(4) }, index);
+    }
+    if (line.startsWith("## ")) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.accentWarm, children: line.slice(3) }, index);
+    }
+    if (line.startsWith("# ")) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.accent, children: line.slice(2) }, index);
+    }
+    if (line.startsWith("- ")) {
+      return /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+        "- ",
+        line.slice(2)
+      ] }, index);
+    }
+    if (/^\d+\.\s/.test(line)) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: line }, index);
+    }
+    if (line.trim().length === 0) {
+      return /* @__PURE__ */ jsx(Text, { children: " " }, index);
+    }
+    return /* @__PURE__ */ jsx(Text, { color: THEME.bright, children: line }, index);
+  }) });
+}
+function useTicker(animate, intervalMs, length) {
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (!animate || length <= 0) {
+      setTick(0);
+      return;
+    }
+    const id = setInterval(() => {
+      setTick((current) => (current + 1) % length);
+    }, intervalMs);
+    return () => clearInterval(id);
+  }, [animate, intervalMs, length]);
+  return tick;
+}
+function tabIndex(tab) {
+  return TABS.findIndex((item) => item.key === tab);
+}
+function tabTitle(tab) {
+  const active = TABS.find((item) => item.key === tab);
+  return active ? active.label : "Overview";
+}
+function buildNeuralField(width, height, frame) {
+  const safeWidth = Math.max(8, width);
+  const safeHeight = Math.max(4, height);
+  const grid = Array.from({ length: safeHeight }, () => Array(safeWidth).fill(" "));
+  const phase = Math.floor(frame / 6);
+  const rng = makeRng(phase * 109 + 97);
+  const nodes = [];
+  const place = (x, y, char, priority = 0) => {
+    if (x < 0 || x >= safeWidth || y < 0 || y >= safeHeight) return;
+    const current = grid[y][x];
+    const currentPriority = current === "*" || current === "O" ? 3 : current === "o" ? 2 : current === "~" ? 1 : 0;
+    if (priority >= currentPriority || current === " ") {
+      grid[y][x] = char;
+    }
+  };
+  for (let y = 0; y < safeHeight; y += 1) {
+    for (let x = 0; x < safeWidth; x += 1) {
+      const roll = rng();
+      if (roll < 0.018) {
+        grid[y][x] = "*";
+        nodes.push({ x, y });
+      } else if (roll < 0.04) {
+        grid[y][x] = "o";
+        nodes.push({ x, y });
+      } else if (roll < 0.12) {
+        grid[y][x] = ".";
+      }
+    }
+  }
+  const mid = Math.floor(safeHeight / 2);
+  const amp = Math.max(1, Math.floor(safeHeight / 3));
+  for (let x = 0; x < safeWidth; x += 1) {
+    const y = Math.round(mid + Math.sin((x + frame * 0.6) / 3) * amp);
+    place(x, y, "~", 1);
+    if ((x + frame) % 11 === 0) place(x, y, "*", 3);
+  }
+  const mid2 = Math.floor(safeHeight / 3);
+  const amp2 = Math.max(1, Math.floor(safeHeight / 4));
+  for (let x = 0; x < safeWidth; x += 1) {
+    const y = Math.round(mid2 + Math.sin((x + frame * 0.4) / 2.6) * amp2);
+    place(x, y, "~", 1);
+    if ((x + frame * 2) % 17 === 0) place(x, y, "o", 2);
+  }
+  const particleCount = Math.max(2, Math.floor(safeWidth / 12));
+  for (let i = 0; i < particleCount; i += 1) {
+    const particleX = (frame * (i + 2) + i * 7) % safeWidth;
+    const particleY = (frame * (i + 3) + i * 5) % safeHeight;
+    place(particleX, particleY, "+", 2);
+  }
+  nodes.forEach((node) => {
+    if (rng() < 0.35) {
+      const length = 2 + Math.floor(rng() * 6);
+      const drift = rng() < 0.5 ? 1 : -1;
+      for (let step = 1; step <= length; step += 1) {
+        const x = node.x + step;
+        const y = node.y + (rng() < 0.3 ? drift : 0);
+        place(x, y, rng() < 0.5 ? "-" : "=", 0);
+      }
+    }
+    if ((node.x + frame) % 14 === 0) {
+      place(node.x, node.y, "O", 3);
+    }
+  });
+  return grid.map((row) => row.join(""));
+}
+function buildAuroraLine(width, frame, offset) {
+  const safeWidth = Math.max(10, width);
+  const chars = [" ", " ", ".", ":", "-", "=", "+", "*"];
+  let line = "";
+  for (let x = 0; x < safeWidth; x += 1) {
+    const phase = (x + frame * 0.9 + offset * 7) / 4;
+    const wave = Math.sin(phase) * 0.6 + Math.sin(phase / 2 + offset) * 0.4 + 1;
+    const normalized = Math.max(0, Math.min(1, wave / 2));
+    const idx = Math.min(chars.length - 1, Math.floor(normalized * (chars.length - 1)));
+    line += chars[idx];
+  }
+  return line;
+}
+function buildInterferenceLine(width, frame, offset) {
+  const safeWidth = Math.max(10, width);
+  const chars = [" ", ".", ":", "-", "=", "+", "*", "#"];
+  let line = "";
+  for (let x = 0; x < safeWidth; x += 1) {
+    const waveA = Math.sin((x + frame * 0.6 + offset * 5) / 3);
+    const waveB = Math.sin((x * 0.6 + frame * 0.3) / 2.1);
+    const waveC = Math.sin((x * 1.2 + frame * 0.9) / 4.6);
+    const mix = (waveA + waveB + waveC + 3) / 6;
+    const idx = Math.min(chars.length - 1, Math.floor(mix * (chars.length - 1)));
+    line += chars[idx];
+  }
+  return line;
+}
+function buildNeuronHalo(width, frame) {
+  const safeWidth = Math.max(10, width);
+  const rng = makeRng((Math.floor(frame / 4) + 11) * 233);
+  let line = "";
+  for (let x = 0; x < safeWidth; x += 1) {
+    const roll = rng();
+    if (roll < 0.04) line += "*";
+    else if (roll < 0.08) line += "o";
+    else if (roll < 0.11) line += ".";
+    else line += " ";
+  }
+  return line;
+}
+function buildPulseMeter(frame, width) {
+  const safeWidth = Math.max(8, width);
+  const head = frame % safeWidth;
+  let line = "";
+  for (let i = 0; i < safeWidth; i += 1) {
+    if (i === head) {
+      line += "*";
+    } else if (Math.abs(i - head) === 1) {
+      line += "+";
+    } else if ((i + frame) % 5 === 0) {
+      line += "-";
+    } else {
+      line += ".";
+    }
+  }
+  return line;
+}
+function buildScanBar(position, width) {
+  const safeWidth = Math.max(8, width);
+  if (position < 0) return "[" + ".".repeat(safeWidth) + "]";
+  const head = position % safeWidth;
+  let line = "";
+  for (let i = 0; i < safeWidth; i += 1) {
+    if (i === head) line += ">";
+    else if (Math.abs(i - head) === 1) line += "=";
+    else line += ".";
+  }
+  return `[${line}]`;
+}
+function makeRng(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967295;
+  };
+}
+function rotatePalette(palette, frame) {
+  if (palette.length === 0) return palette;
+  const offset = frame % palette.length;
+  return [...palette.slice(offset), ...palette.slice(0, offset)];
+}
+function useProgress(active, durationMs, stepMs) {
+  const [progress, setProgress] = useState(active ? 0 : 1);
+  useEffect(() => {
+    if (!active) {
+      setProgress(1);
+      return;
+    }
+    setProgress(0);
+    const start = Date.now();
+    const id = setInterval(() => {
+      const value = Math.min(1, (Date.now() - start) / durationMs);
+      setProgress(value);
+      if (value >= 1) clearInterval(id);
+    }, stepMs);
+    return () => clearInterval(id);
+  }, [active, durationMs, stepMs]);
+  return progress;
+}
+function IntroScreen(props) {
+  const { width, height, progress, frame } = props;
+  const fieldWidth = Math.max(24, width - 6);
+  const fieldHeight = Math.max(10, Math.min(14, height));
+  const steps = INTRO_STEPS.map((label, index) => ({
+    label,
+    done: progress >= (index + 1) / INTRO_STEPS.length
+  }));
+  const bar = buildProgressBar(progress, Math.max(16, Math.min(34, Math.floor(width / 3))));
+  const palette = rotatePalette(WORDMARK_COLORS, frame);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", children: [
+      /* @__PURE__ */ jsx(Wordmark, { lines: WORDMARK_LINES, palette }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Neural ignition sequence" })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", alignItems: "center", children: /* @__PURE__ */ jsx(ColorLine, { text: bar, color: THEME.accentWarm }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: steps.map((step, index) => /* @__PURE__ */ jsxs(Text, { color: step.done ? THEME.accent : THEME.muted, children: [
+      "[",
+      step.done ? "x" : " ",
+      "] ",
+      step.label
+    ] }, index)) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(NeuralField, { width: fieldWidth, height: fieldHeight, frame, animate: true }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: INTRO_HINTS.map((hint) => /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: hint }, hint)) })
+  ] });
+}
+function buildProgressBar(progress, width) {
+  const safeWidth = Math.max(10, width);
+  const filled = Math.round(progress * safeWidth);
+  const left = "=".repeat(filled);
+  const right = ".".repeat(Math.max(0, safeWidth - filled));
+  return `[${left}${right}]`;
+}
+
+// src/commands/brain.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+async function brainCommand(opts) {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  const apiKey = await readApiKeyFromEnv(cwd);
+  const packageManager = detectPackageManager(cwd);
+  const snapshot = config ? {
+    name: config.project.name,
+    template: config.project.template,
+    framework: config.project.framework,
+    port: config.dev.port,
+    devCommand: config.dev.command,
+    apiBaseUrl: config.api.baseUrl,
+    apiKeyConfigured: Boolean(apiKey),
+    packageManager
+  } : null;
+  const app = render(/* @__PURE__ */ jsx2(App, { snapshot, animate: opts.anim !== false }));
+  await app.waitUntilExit();
+}
+
+// src/commands/studio.tsx
+async function studioCommand(opts) {
+  await brainCommand(opts);
+}
+
+// src/commands/browser-use.ts
+import pc8 from "picocolors";
+import { BrowserUse } from "browser-use-sdk";
+function getClient() {
+  const apiKey = process.env.BROWSER_USE_API_KEY;
+  if (!apiKey) {
+    throw new Error("BROWSER_USE_API_KEY is required");
+  }
+  return new BrowserUse({
+    apiKey,
+    baseUrl: process.env.BROWSER_USE_BASE_URL || void 0
+  });
+}
+async function browserUseRunCommand(opts) {
+  if (!opts.task) {
+    throw new Error("--task is required");
+  }
+  const client = getClient();
+  const result = await client.run(opts.task, {
+    startUrl: opts.startUrl,
+    maxSteps: opts.maxSteps ? Number.parseInt(opts.maxSteps, 10) : void 0,
+    timeout: opts.wait === false ? 1e4 : 3e5
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(pc8.green("Browser Use task complete"));
+  console.log(`${pc8.dim("Task:")} ${opts.task}`);
+  console.log(`${pc8.dim("Status:")} ${result.status}`);
+  if (result.output) {
+    console.log(`${pc8.dim("Output:")} ${String(result.output)}`);
+  }
+}
+async function browserUseMcpSnippetCommand(opts) {
+  const target = opts.target || "generic";
+  if (target === "generic") {
+    console.log(JSON.stringify({
+      name: "browser-use",
+      transport: "streamable-http",
+      url: "https://api.browser-use.com/mcp",
+      headers: {
+        Authorization: "Bearer ${BROWSER_USE_API_KEY}"
+      }
+    }, null, 2));
+    return;
+  }
+  if (target === "codex") {
+    console.log([
+      "[mcp_servers.browser_use]",
+      'url = "https://api.browser-use.com/mcp"',
+      "",
+      "[mcp_servers.browser_use.http_headers]",
+      'Authorization = "Bearer ${BROWSER_USE_API_KEY}"'
+    ].join("\n"));
+    return;
+  }
+  if (target === "claude-code") {
+    console.log(JSON.stringify({
+      mcpServers: {
+        "browser-use": {
+          type: "http",
+          url: "https://api.browser-use.com/mcp",
+          headers: {
+            Authorization: "Bearer ${BROWSER_USE_API_KEY}"
+          }
+        }
+      }
+    }, null, 2));
+    return;
+  }
+  throw new Error(`Unsupported target "${target}". Use generic, codex, or claude-code.`);
+}
+
+// src/commands/api.ts
+import pc10 from "picocolors";
+
+// src/lib/api.ts
+init_config();
+init_env();
+init_logger();
+import pc9 from "picocolors";
+async function getApiContext(cwd) {
+  const config = await readConfig(cwd);
+  const apiKey = await readApiKeyFromEnv(cwd);
+  if (!apiKey) {
+    log.error("No API key configured.");
+    log.info(`Run ${pc9.bold("recursiv auth login")} to set your key.`);
+    process.exit(1);
+  }
+  return {
+    baseUrl: config?.api.baseUrl ?? "https://api.recursiv.io/api/v1",
+    apiKey
+  };
+}
+async function apiRequest(ctx, opts) {
+  const url = new URL(opts.path, ctx.baseUrl.endsWith("/") ? ctx.baseUrl : ctx.baseUrl + "/");
+  if (opts.query) {
+    Object.entries(opts.query).forEach(([key, value]) => {
+      if (value === void 0 || value === null || value === "") return;
+      url.searchParams.set(key, String(value));
+    });
+  }
+  const res = await fetch(url, {
+    method: opts.method,
+    headers: {
+      Authorization: `Bearer ${ctx.apiKey}`,
+      Accept: "application/json",
+      ...opts.body ? { "Content-Type": "application/json" } : {}
+    },
+    body: opts.body ? JSON.stringify(opts.body) : void 0
+  });
+  const text = await res.text();
+  const payload = safeJson(text);
+  if (!res.ok) {
+    const message = payload?.error?.message || payload?.message || `Request failed (${res.status} ${res.statusText})`;
+    throw new Error(message);
+  }
+  return payload ?? {};
+}
+function safeJson(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/api.ts
+init_logger();
+async function usersMeCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, { method: "GET", path: "users/me" });
+  output(res, opts.json, (data) => {
+    log.blank();
+    console.log(pc10.bold("User"));
+    console.log(`  ${pc10.dim("id")}: ${data.id}`);
+    console.log(`  ${pc10.dim("name")}: ${data.name ?? "-"}`);
+    console.log(`  ${pc10.dim("username")}: ${data.username ?? "-"}`);
+    console.log(`  ${pc10.dim("email")}: ${data.email ?? "-"}`);
+    console.log(`  ${pc10.dim("followers")}: ${data.followers_count ?? 0}`);
+    console.log(`  ${pc10.dim("following")}: ${data.following_count ?? 0}`);
+    console.log(`  ${pc10.dim("posts")}: ${data.posts_count ?? 0}`);
+    log.blank();
+  });
+}
+async function communitiesListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "communities",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc10.bold("Communities"));
+    data.forEach((comm) => {
+      const name = pc10.bold(comm.name);
+      const slug = comm.slug ? pc10.dim(`/${comm.slug}`) : "";
+      const members = pc10.dim(`members ${comm.member_count ?? 0}`);
+      console.log(`  ${name} ${slug} ${members}`);
+      if (comm.description) console.log(`    ${pc10.dim(comm.description)}`);
+    });
+    printMeta(meta);
+  });
+}
+async function communitiesCreateCommand(opts) {
+  if (!opts.name || !opts.slug) {
+    log.error("Missing required flags: --name and --slug");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "communities",
+    body: {
+      name: opts.name,
+      slug: opts.slug,
+      description: opts.description,
+      privacy: opts.privacy ?? "public"
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Community created: ${pc10.bold(data.name)} (${data.id})`);
+  });
+}
+async function postsListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "posts",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset,
+      community_id: opts.communityId,
+      author_id: opts.authorId
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc10.bold("Posts"));
+    data.forEach((post) => {
+      const author = post.author?.username ? `@${post.author.username}` : "unknown";
+      const content = truncate(post.content ?? "", 100);
+      console.log(`  ${pc10.bold(author)} ${pc10.dim(post.id)}`);
+      console.log(`    ${content}`);
+    });
+    printMeta(meta);
+  });
+}
+async function postsCreateCommand(opts) {
+  if (!opts.content) {
+    log.error("Missing required flag: --content");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const tagIds = opts.tagIds ? opts.tagIds.split(",").map((id) => id.trim()).filter(Boolean) : void 0;
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "posts",
+    body: {
+      content: opts.content,
+      content_format: opts.markdown ? "markdown" : "plain",
+      community_id: opts.communityId,
+      organization_id: opts.organizationId,
+      reply_to_id: opts.replyToId,
+      tag_ids: tagIds
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Post created: ${pc10.dim(data.id)}`);
+  });
+}
+async function projectsListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "projects",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset,
+      organization_id: opts.organizationId
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc10.bold("Projects"));
+    data.forEach((proj) => {
+      const name = pc10.bold(proj.name);
+      const slug = proj.slug ? pc10.dim(`/${proj.slug}`) : "";
+      const org = proj.organization?.slug ? pc10.dim(`org ${proj.organization.slug}`) : "";
+      console.log(`  ${name} ${slug} ${org}`);
+    });
+    printMeta(meta);
+  });
+}
+async function projectsCreateCommand(opts) {
+  if (!opts.organizationId || !opts.name) {
+    log.error("Missing required flags: --org and --name");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "projects",
+    body: {
+      organization_id: opts.organizationId,
+      name: opts.name,
+      slug: opts.slug,
+      repo_url: opts.repoUrl,
+      template_source: opts.templateSource ?? "default",
+      custom_template_url: opts.templateUrl
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Project created: ${pc10.bold(data.name)} (${data.id})`);
+  });
+}
+async function agentsListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "agents",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc10.bold("Agents"));
+    data.forEach((agent) => {
+      const name = pc10.bold(agent.name);
+      const handle = agent.username ? pc10.dim(`@${agent.username}`) : "";
+      const model = agent.model ? pc10.dim(agent.model) : "";
+      console.log(`  ${name} ${handle} ${model}`);
+    });
+    printMeta(meta);
+  });
+}
+async function agentsCreateCommand(opts) {
+  if (!opts.name || !opts.username) {
+    log.error("Missing required flags: --name and --username");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "agents",
+    body: {
+      name: opts.name,
+      username: opts.username,
+      bio: opts.bio,
+      model: opts.model,
+      system_prompt: opts.systemPrompt,
+      social_mode: opts.socialMode,
+      post_frequency: opts.postFrequency,
+      tool_mode: opts.toolMode,
+      daily_request_limit: opts.dailyRequestLimit ? Number(opts.dailyRequestLimit) : void 0,
+      organization_id: opts.organizationId
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Agent created: ${pc10.bold(data.name)} (${data.id})`);
+  });
+}
+function output(res, json, render2) {
+  if (json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  render2(res.data, res.meta);
+}
+function printMeta(meta) {
+  if (!meta) return;
+  log.blank();
+  console.log(pc10.dim(`limit ${meta.limit ?? 0} offset ${meta.offset ?? 0} has_more ${meta.has_more ?? false}`));
+  log.blank();
+}
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  return value.slice(0, max - 1) + "\u2026";
+}
+
+// src/bin/recursiv.ts
+var program = new Command();
+program.name("recursiv").description("Recursiv CLI \u2014 build and ship apps with AI").version("0.1.0");
+program.command("chat").description("Start the chat-first AI agent (default when no command is given)").option("--model <model>", "Claude model to use (default: claude-sonnet-4-20250514)").option("--resume", "Resume the most recent session").action(async (opts) => {
+  try {
+    await launchChatAgent({ model: opts.model, resume: opts.resume });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("create [name]").description("Create a new Recursiv application").action(async (name) => {
+  try {
+    await initCommand(name);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("dev").description("Start the development server").option("-p, --port <port>", "port to run on").action(async (opts) => {
+  try {
+    await devCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("deploy <target>").description("Generate deployment config (vercel, docker, render, railway, cloud)").action(async (target) => {
+  try {
+    await deployCommand(target);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var auth = program.command("auth").description("Manage API authentication");
+auth.command("login").description("Set or update your API key").action(async () => {
+  try {
+    await loginCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+auth.command("logout").description("Remove API key from .env").action(async () => {
+  try {
+    await logoutCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+auth.command("whoami").description("Show current authenticated user").action(async () => {
+  try {
+    await whoamiCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("info").description("Display project information").action(async () => {
+  try {
+    await infoCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var browserUse = program.command("browser-use").description("Browser Use helpers");
+browserUse.command("run").description("Run a Browser Use task with the official SDK").requiredOption("--task <task>", "task to run").option("--start-url <url>", "initial URL").option("--max-steps <n>", "maximum Browser Use steps").option("--no-wait", "return quickly instead of waiting for the full result").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await browserUseRunCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+browserUse.command("mcp-snippet").description("Print Browser Use MCP configuration snippets").option("--target <target>", "generic | codex | claude-code", "generic").action(async (opts) => {
+  try {
+    await browserUseMcpSnippetCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var users = program.command("users").description("Users API");
+users.command("me").description("Show current authenticated user").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await usersMeCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var communities = program.command("communities").description("Communities API");
+communities.command("list").description("List communities").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await communitiesListCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+communities.command("create").description("Create a community").requiredOption("--name <name>", "community name").requiredOption("--slug <slug>", "community slug").option("--description <description>", "description").option("--privacy <privacy>", "public | private | hidden", "public").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await communitiesCreateCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var posts = program.command("posts").description("Posts API");
+posts.command("list").description("List posts").option("--community-id <id>", "filter by community").option("--author-id <id>", "filter by author").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await postsListCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+posts.command("create").description("Create a post").requiredOption("--content <content>", "post content").option("--markdown", "content is markdown").option("--community-id <id>", "community id").option("--organization-id <id>", "organization id").option("--reply-to-id <id>", "reply to post id").option("--tag-ids <ids>", "comma-separated tag ids").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await postsCreateCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var projects = program.command("projects").description("Projects API");
+projects.command("list").description("List projects").option("--org <id>", "organization id").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await projectsListCommand({
+      organizationId: opts.org,
+      limit: opts.limit,
+      offset: opts.offset,
+      json: opts.json
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+projects.command("create").description("Create a project").requiredOption("--org <id>", "organization id").requiredOption("--name <name>", "project name").option("--slug <slug>", "project slug").option("--repo <url>", "repo URL").option("--template <source>", "default | custom", "default").option("--template-url <url>", "custom template URL").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await projectsCreateCommand({
+      organizationId: opts.org,
+      name: opts.name,
+      slug: opts.slug,
+      repoUrl: opts.repo,
+      templateSource: opts.template,
+      templateUrl: opts.templateUrl,
+      json: opts.json
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var agents = program.command("agents").description("Agents API");
+agents.command("list").description("List agents").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await agentsListCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+agents.command("create").description("Create an AI agent").requiredOption("--name <name>", "agent name").requiredOption("--username <username>", "agent username").option("--bio <bio>", "agent bio").option("--model <model>", "model id").option("--system-prompt <prompt>", "system prompt").option("--social-mode <mode>", "chat_only | chat_post").option("--post-frequency <freq>", "never | light | medium | heavy").option("--tool-mode <mode>", "chat_only | permission | autonomous").option("--daily-request-limit <n>", "daily request limit").option("--org <id>", "organization id").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await agentsCreateCommand({
+      name: opts.name,
+      username: opts.username,
+      bio: opts.bio,
+      model: opts.model,
+      systemPrompt: opts.systemPrompt,
+      socialMode: opts.socialMode,
+      postFrequency: opts.postFrequency,
+      toolMode: opts.toolMode,
+      dailyRequestLimit: opts.dailyRequestLimit,
+      organizationId: opts.org,
+      json: opts.json
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("brain").description("Launch the visual Recursiv brain TUI").option("--no-anim", "Disable animations").action(async (opts) => {
+  try {
+    await brainCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("studio").description("Legacy alias for brain").option("--no-anim", "Disable animations").action(async (opts) => {
+  try {
+    await studioCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var mcp = program.command("mcp").description("Manage MCP server integrations");
+mcp.command("install <target>").description("Configure Recursiv MCP server for a host (claude-code, claude-desktop, codex, opencode)").option("--api-key <key>", "Recursiv API key (defaults to RECURSIV_API_KEY env var)").option("--global", "Install globally instead of project-level (claude-code, opencode)").action(async (target, opts) => {
+  try {
+    const { mcpInstallCommand: mcpInstallCommand2 } = await Promise.resolve().then(() => (init_mcp_install(), mcp_install_exports));
+    await mcpInstallCommand2({ target, apiKey: opts.apiKey, global: opts.global });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+mcp.command("verify").description("Verify that the Recursiv MCP server starts and responds").action(async () => {
+  try {
+    const { mcpVerifyCommand: mcpVerifyCommand2 } = await Promise.resolve().then(() => (init_mcp_install(), mcp_install_exports));
+    await mcpVerifyCommand2();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+async function launchChatAgent(opts) {
+  const { startAgent: startAgent2 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
+  const { readConfig: readConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { resolveRecursivKey: resolveRecursivKey2, resolveAnthropicKey: resolveAnthropicKey2, saveCredentials: saveCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const { getOrCreateApiKey: getOrCreateApiKey2 } = await Promise.resolve().then(() => (init_auth_flow(), auth_flow_exports));
+  const pc14 = (await import("picocolors")).default;
+  const prompts3 = (await import("prompts")).default;
+  const cwd = process.cwd();
+  const config = await readConfig2(cwd);
+  const baseUrl = config?.api.baseUrl ?? "https://api.recursiv.io/api/v1";
+  let recursivApiKey = await resolveRecursivKey2(cwd);
+  if (!recursivApiKey) {
+    console.log();
+    console.log(pc14.bold("  Welcome to Recursiv"));
+    console.log(pc14.dim("  Let's get you authenticated."));
+    console.log();
+    recursivApiKey = await getOrCreateApiKey2(baseUrl);
+    if (!recursivApiKey) {
+      console.error(pc14.red("  error") + " Authentication required to continue.");
+      process.exit(1);
+    }
+    await saveCredentials2({ recursivApiKey });
+    console.log(pc14.dim("  Credentials saved to ~/.recursiv/credentials"));
+    console.log();
+  }
+  const anthropicApiKey = await resolveAnthropicKey2() ?? void 0;
+  await startAgent2({
+    recursivApiKey,
+    recursivBaseUrl: baseUrl,
+    model: opts?.model,
+    resume: opts?.resume,
+    anthropicApiKey
+  });
+}
+function shouldAutoLaunchChat(args) {
+  if (process.env.RECURSIV_BRAIN === "1") return false;
+  if (process.env.RECURSIV_STUDIO === "1") return false;
+  if (args.length > 0) return false;
+  if (!process.stdout.isTTY) return false;
+  if (process.env.CI) return false;
+  return true;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--brain") || args.includes("--studio")) {
+    const filtered = args.filter((arg) => arg !== "--brain" && arg !== "--studio");
+    process.argv = [process.argv[0], process.argv[1], ...filtered];
+    const noAnim = filtered.includes("--no-anim");
+    await brainCommand({ anim: !noAnim });
+    return;
+  }
+  if (shouldAutoLaunchChat(args)) {
+    try {
+      await launchChatAgent();
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+    return;
+  }
+  program.parse();
+}
+void main();
+//# sourceMappingURL=recursiv.js.map