@0dai-dev/cli 3.10.0 → 4.0.0

package/lib/commands/swarm.js

@@ -0,0 +1,161 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, https, requirePlan } = shared;
+
+function cmdSwarm(target, sub, args) {
+  const swarmDir = path.join(target, "ai", "swarm");
+  const queueDir = path.join(swarmDir, "queue");
+
+  if (sub === "status") {
+    const count = (d) => { try { return fs.readdirSync(d).filter(f => f.endsWith(".json")).length; } catch { return 0; } };
+    const q = count(path.join(swarmDir, "queue"));
+    const a = count(path.join(swarmDir, "active"));
+    const d = count(path.join(swarmDir, "done"));
+    log(`swarm: ${q} queued, ${a} active, ${d} done`);
+    return;
+  }
+  if (sub === "add" || sub === "delegate") {
+    const gate = requirePlan("pro", "Swarm", target);
+    if (gate) { log(gate.error); log(gate.hint); return; }
+    fs.mkdirSync(queueDir, { recursive: true });
+    const task = args.find((_, i) => args[i - 1] === "--task") || "untitled";
+    const forAgent = args.find((_, i) => ["--for", "--to"].includes(args[i - 1])) || "any";
+    const id = `swarm-${Date.now()}`;
+    const t = { id, title: task, assigned_to: forAgent, status: "pending", created_at: new Date().toISOString(), created_by: "cli" };
+    fs.writeFileSync(path.join(queueDir, `${id}.json`), JSON.stringify(t, null, 2));
+    log(`task created: ${id} → ${forAgent}`);
+    return;
+  }
+  if (sub === "webhook") {
+    const webhooksFile = path.join(swarmDir, "webhooks.json");
+    const loadHooks = () => { try { return JSON.parse(fs.readFileSync(webhooksFile, "utf8")); } catch { return []; } };
+    const saveHooks = (h) => { fs.mkdirSync(swarmDir, { recursive: true }); fs.writeFileSync(webhooksFile, JSON.stringify(h, null, 2)); };
+    const action = args[2] || "";
+
+    if (action === "add") {
+      const url = args[3] || args.find((_, i) => args[i-1] === "--url");
+      const event = args.find((_, i) => args[i-1] === "--event") || "all";
+      const secret = args.find((_, i) => args[i-1] === "--secret") || "";
+      if (!url || !url.startsWith("http")) { log("Usage: 0dai swarm webhook add <url> [--event task_done|task_failed|all] [--secret TOKEN]"); return; }
+      // MED: SSRF protection — block internal/metadata endpoints
+      try {
+        const u = new URL(url);
+        const host = u.hostname;
+        const BLOCKED = /^(127\.|10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[01])\.|169\.254\.|::1$|fc00:|fe80:|localhost$|0\.0\.0\.0$)/i;
+        if (BLOCKED.test(host) || host === "metadata.google.internal") {
+          log(`rejected: ${host} is a private/internal address (SSRF protection)`);
+          return;
+        }
+        if (u.protocol !== "https:" && u.protocol !== "http:") {
+          log(`rejected: only http/https allowed, got ${u.protocol}`);
+          return;
+        }
+      } catch {
+        log(`invalid URL: ${url}`);
+        return;
+      }
+      const hooks = loadHooks();
+      if (hooks.find(h => h.url === url)) { log(`already registered: ${url}`); return; }
+      hooks.push({ url, event, secret: secret || undefined, added_at: new Date().toISOString() });
+      saveHooks(hooks);
+      log(`webhook added: ${url} (event: ${event})`);
+      return;
+    }
+    if (action === "list") {
+      const hooks = loadHooks();
+      if (hooks.length === 0) { log("no webhooks registered. Use: 0dai swarm webhook add <url>"); return; }
+      console.log(`\n  ${T}Registered webhooks${R}\n`);
+      hooks.forEach((h, i) => {
+        console.log(`  ${i+1}. ${h.url}`);
+        console.log(`     ${D}event: ${h.event}  added: ${h.added_at?.slice(0,10)}${R}`);
+      });
+      console.log();
+      return;
+    }
+    if (action === "remove") {
+      const url = args[3] || "";
+      if (!url) { log("Usage: 0dai swarm webhook remove <url>"); return; }
+      const hooks = loadHooks().filter(h => h.url !== url);
+      saveHooks(hooks);
+      log(`removed: ${url}`);
+      return;
+    }
+    if (action === "test") {
+      const url = args[3] || loadHooks()[0]?.url;
+      if (!url) { log("Usage: 0dai swarm webhook test <url>"); return; }
+      const payload = JSON.stringify({ event: "test", task_id: "test-ping", title: "Webhook test from 0dai", status: "done", timestamp: new Date().toISOString() });
+      const req = https.request(url, { method: "POST", headers: { "Content-Type": "application/json", "User-Agent": "0dai-swarm/1.0", "Content-Length": Buffer.byteLength(payload) } }, (res) => {
+        log(`test sent to ${url} → HTTP ${res.statusCode}`);
+      });
+      req.on("error", (e) => log(`test failed: ${e.message}`));
+      req.setTimeout(5000, () => { req.destroy(); log("test timed out"); });
+      req.write(payload);
+      req.end();
+      return;
+    }
+    console.log("Usage: 0dai swarm webhook [add|list|remove|test] <url> [--event all|task_done|task_failed] [--secret TOKEN]");
+    return;
+  }
+  if (sub === "budget") {
+    const budgetFile = path.join(swarmDir, "budget.json");
+    if (!fs.existsSync(budgetFile)) { log("no budget data yet"); return; }
+    const b = JSON.parse(fs.readFileSync(budgetFile, "utf8"));
+    const B2 = process.stdout.isTTY ? "\x1b[1m" : "";
+    const R2 = process.stdout.isTTY ? "\x1b[0m" : "";
+    const D2 = process.stdout.isTTY ? "\x1b[2m" : "";
+    const G2 = process.stdout.isTTY ? "\x1b[32m" : "";
+    const W2 = process.stdout.isTTY ? "\x1b[33m" : "";
+    const today = new Date().toISOString().slice(0, 10);
+    const sessionKey = process.env.ODAI_SESSION_ID ||
+      new Date().toISOString().slice(0, 13).replace("T", "-");
+    const dailySpent = b.daily?.[today] || 0;
+    const totalSpent = b.total_spent || 0;
+    const sess = b.sessions?.[sessionKey];
+    // Tier distribution across all tasks
+    const tierCount = { fast: 0, balanced: 0, deep: 0 };
+    for (const t of Object.values(b.tasks || {})) {
+      if (t.tier && tierCount[t.tier] !== undefined) tierCount[t.tier]++;
+    }
+    const tieredTotal = tierCount.fast + tierCount.balanced + tierCount.deep;
+    console.log(`\n  ${B2}Swarm Budget${R2}`);
+    if (sess && sess.total_cost > 0) {
+      const taskCount = (sess.tasks || []).length;
+      const avgCost = taskCount > 0 ? (sess.total_cost / taskCount).toFixed(4) : "0";
+      console.log(`    ${B2}This session${R2}  $${sess.total_cost.toFixed(4)} · ${taskCount} tasks · avg $${avgCost}/task`);
+      if (sess.tiers) {
+        const tiers = Object.entries(sess.tiers).filter(([, n]) => n > 0).map(([t, n]) => `${n}×${t}`).join("  ");
+        if (tiers) console.log(`    ${D2}Tiers          ${tiers}${R2}`);
+      }
+    } else {
+      console.log(`    ${D2}This session   no tracked spend${R2}`);
+    }
+    if (dailySpent > 0) {
+      const dailyLimit = parseFloat(process.env.ODAI_DAILY_BUDGET || "5");
+      const pct = Math.round((dailySpent / dailyLimit) * 100);
+      const bar = "█".repeat(Math.round(pct / 5)).padEnd(20, "░");
+      const col = pct < 50 ? G2 : pct < 80 ? W2 : "\x1b[31m";
+      console.log(`    ${B2}Today${R2}         ${col}$${dailySpent.toFixed(4)}${R2} / $${dailyLimit.toFixed(2)} ${D2}${bar} ${pct}%${R2}`);
+    }
+    console.log(`    ${B2}All time${R2}      ${D2}$${totalSpent.toFixed(4)} (${Object.keys(b.tasks || {}).length} tasks)${R2}`);
+    if (tieredTotal > 0) {
+      const fastPct = Math.round((tierCount.fast / tieredTotal) * 100);
+      console.log(`    ${D2}Model routing  ${tierCount.fast}×fast  ${tierCount.balanced}×balanced  ${tierCount.deep}×deep  (${fastPct}% cheap)${R2}`);
+    }
+    // Recent sessions (last 5)
+    const sessions = Object.entries(b.sessions || {})
+      .sort(([a], [bb]) => bb.localeCompare(a))
+      .slice(0, 5);
+    if (sessions.length > 1) {
+      console.log(`    ${D2}Recent sessions:${R2}`);
+      for (const [key, s] of sessions) {
+        const tasks = (s.tasks || []).length;
+        console.log(`      ${D2}${key}  $${(s.total_cost || 0).toFixed(4)} · ${tasks} tasks${R2}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  console.log("Usage: 0dai swarm [status|add|delegate|budget] [--task '...'] [--to agent]");
+}
+
+module.exports = { cmdSwarm };

package/lib/commands/update.js

@@ -0,0 +1,69 @@
+"use strict";
+const shared = require("../shared");
+const { log, SUPPORTED_CLIS } = shared;
+
+function cmdUpdate(args) {
+  const { execFileSync: _ef3, execSync } = require("child_process");
+  const dryRun = args.includes("--dry-run");
+
+  // 0dai self-update entry, then all supported agent CLIs.
+  const CLIS = [
+    { name: "0dai", pkg: "@0dai-dev/cli", bin: "0dai", pkgType: "npm" },
+    ...SUPPORTED_CLIS,
+  ];
+
+  let updated = 0;
+  for (const cli of CLIS) {
+    let installed = false, ver = null;
+    try {
+      const out = _ef3(cli.bin, ["--version"], { timeout: 8000 }).toString().trim();
+      installed = true;
+      const m = out.match(/(\d+\.\d+\.\d+)/);
+      if (m) ver = m[1];
+    } catch {}
+
+    if (!installed) continue;
+
+    let latest = null;
+    if (cli.pkgType === "npm" && cli.pkg) {
+      try { latest = _ef3("npm", ["view", cli.pkg, "version"], { timeout: 5000 }).toString().trim(); } catch {}
+    } else if (cli.pkgType === "pip" && cli.pkg) {
+      try {
+        const out = _ef3("pip", ["index", "versions", cli.pkg], { timeout: 8000, encoding: "utf8" });
+        const m = out.match(/LATEST:\s*(\d+\.\d+\.\d+)/i) || out.match(/(\d+\.\d+\.\d+)/);
+        if (m) latest = m[1];
+      } catch {}
+    }
+
+    if (!latest || latest === ver) {
+      console.log(`  ${cli.name} ${ver || ""} — up to date`);
+      continue;
+    }
+
+    console.log(`  ${cli.name} ${ver} → ${latest}`);
+    if (dryRun) { updated++; continue; }
+
+    try {
+      if (cli.pkgType === "npm") {
+        log(`updating ${cli.name}...`);
+        execSync(`npm install -g ${cli.pkg}@latest`, { timeout: 60000, stdio: "pipe" });
+        log(`${cli.name} updated to ${latest}`);
+        updated++;
+      } else if (cli.pkgType === "pip") {
+        log(`updating ${cli.name}...`);
+        execSync(`pip install --upgrade ${cli.pkg}`, { timeout: 60000, stdio: "pipe" });
+        log(`${cli.name} updated to ${latest}`);
+        updated++;
+      }
+    } catch (e) {
+      log(`failed to update ${cli.name}: ${e.message.split("\n")[0]}`);
+    }
+  }
+  if (updated) {
+    log(`${dryRun ? "would update" : "updated"} ${updated} CLI(s)`);
+  } else {
+    log("all CLIs are up to date");
+  }
+}
+
+module.exports = { cmdUpdate };

package/lib/commands/validate.js

@@ -0,0 +1,71 @@
+"use strict";
+const shared = require("../shared");
+const { log, fs, path, SUPPORTED_CLIS } = shared;
+
+function cmdValidate(target) {
+  const ai = path.join(target, "ai");
+  if (!fs.existsSync(ai)) {
+    log("No 0dai config found. Run: 0dai init");
+    process.exitCode = 1;
+    return;
+  }
+  const E = process.stdout.isTTY ? "\x1b[31m" : "";
+  const G = process.stdout.isTTY ? "\x1b[32m" : "";
+  const D2 = process.stdout.isTTY ? "\x1b[2m" : "";
+  const R2 = process.stdout.isTTY ? "\x1b[0m" : "";
+
+  const required = [
+    "ai/VERSION", "ai/VERSION_SCHEMA",
+    "ai/manifest/project.yaml", "ai/manifest/discovery.json",
+    "ai/manifest/applied-lock.json", "ai/manifest/environment.yaml",
+    "ai/manifest/commands.yaml",
+  ];
+
+  let agents = [];
+  try {
+    agents = JSON.parse(fs.readFileSync(path.join(ai, "manifest", "discovery.json"), "utf8")).selected_agents || [];
+  } catch {}
+
+  const agentFiles = Object.fromEntries(
+    SUPPORTED_CLIS
+      .filter((c) => c.agentFiles && c.agentFiles.length > 0)
+      .map((c) => [c.name, c.agentFiles])
+  );
+  for (const agent of agents) {
+    for (const f of agentFiles[agent] || []) required.push(f);
+  }
+
+  const FIX_HINTS = {
+    "ai/VERSION": "run: 0dai init",
+    "ai/VERSION_SCHEMA": "run: 0dai sync",
+    "ai/manifest/project.yaml": "run: 0dai init",
+    "ai/manifest/discovery.json": "run: 0dai init",
+    "ai/manifest/applied-lock.json": "run: 0dai sync",
+    "ai/manifest/environment.yaml": "run: 0dai sync",
+    "ai/manifest/commands.yaml": "run: 0dai sync",
+    "AGENTS.md": "run: 0dai sync",
+    ".claude/settings.json": "run: 0dai sync",
+    ".claude/CLAUDE.md": "run: 0dai sync",
+    ".mcp.json": "run: 0dai sync",
+    ".codex/config.toml": "install codex, then: 0dai sync",
+    "opencode.json": "install opencode, then: 0dai sync",
+  };
+
+  const present = required.filter(f => fs.existsSync(path.join(target, f)));
+  const missing = required.filter(f => !fs.existsSync(path.join(target, f)));
+
+  for (const f of present) console.log(`  ${G}✓${R2} ${f}`);
+  for (const f of missing) {
+    const hint = FIX_HINTS[f] || "run: 0dai sync";
+    console.log(`  ${E}✗${R2} ${f} ${D2}— ${hint}${R2}`);
+  }
+
+  if (missing.length) {
+    console.log(`\n${E}${missing.length} missing${R2} / ${present.length + missing.length} total`);
+    process.exitCode = 1;
+  } else {
+    log(`${G}validate ok${R2} — all ${present.length} required files present`);
+  }
+}
+
+module.exports = { cmdValidate };

package/lib/commands/watch.js

@@ -0,0 +1,118 @@
+"use strict";
+const shared = require("../shared");
+const { T, fs, path } = shared;
+
+function cmdWatch(target, args) {
+  const isTTY = process.stdout.isTTY;
+  const B2 = isTTY ? "\x1b[1m" : "";
+  const DIM = isTTY ? "\x1b[2m" : "";
+  const G = isTTY ? "\x1b[32m" : "";
+  const Y = isTTY ? "\x1b[33m" : "";
+  const C = isTTY ? "\x1b[36m" : "";
+  const M = isTTY ? "\x1b[35m" : "";
+  const R2 = isTTY ? "\x1b[0m" : "";
+
+  const swarmDir = path.join(target, "ai", "swarm");
+  const interval = parseInt(args.find((_, i) => args[i - 1] === "--interval") || "3", 10) * 1000;
+
+  function readDir(dir) {
+    try {
+      return fs.readdirSync(dir)
+        .filter(f => f.endsWith(".json"))
+        .map(f => { try { return JSON.parse(fs.readFileSync(path.join(dir, f), "utf8")); } catch { return null; } })
+        .filter(Boolean);
+    } catch { return []; }
+  }
+
+  function ago(ts) {
+    if (!ts) return "—";
+    const s = Math.floor((Date.now() - new Date(ts).getTime()) / 1000);
+    if (s < 60) return `${s}s`;
+    if (s < 3600) return `${Math.floor(s / 60)}m`;
+    return `${Math.floor(s / 3600)}h`;
+  }
+
+  function tierColor(tier) {
+    if (tier === "deep") return M;
+    if (tier === "fast") return C;
+    return G;
+  }
+
+  function statusColor(status) {
+    if (status === "done") return G;
+    if (status === "active" || status === "running") return Y;
+    if (status === "failed") return "\x1b[31m";
+    return DIM;
+  }
+
+  function render() {
+    const queue  = readDir(path.join(swarmDir, "queue"));
+    const active = readDir(path.join(swarmDir, "active"));
+    const done   = readDir(path.join(swarmDir, "done")).sort(
+      (a, b) => new Date(b.completed_at || b.created_at) - new Date(a.completed_at || a.created_at)
+    ).slice(0, 8);
+
+    const lines = [];
+    const w = process.stdout.columns || 100;
+    const sep = DIM + "─".repeat(Math.min(w, 96)) + R2;
+
+    lines.push(`\n  ${B2}${T}0dai watch${R2}  ${DIM}${new Date().toLocaleTimeString()}  (q to quit)${R2}`);
+    lines.push(sep);
+
+    const header = `  ${"STATUS".padEnd(9)} ${"AGENT".padEnd(10)} ${"TIER".padEnd(9)} ${"AGE".padEnd(6)}  TITLE`;
+    lines.push(DIM + header + R2);
+    lines.push(sep);
+
+    const printTask = (t, statusOverride) => {
+      const status = statusOverride || t.status || "queued";
+      const sc = statusColor(status);
+      const tc = tierColor(t.model_tier);
+      const title = (t.title || "—").slice(0, Math.max(20, w - 42));
+      const age = ago(t.created_at);
+      lines.push(
+        `  ${sc}${status.padEnd(9)}${R2} ` +
+        `${DIM}${(t.assigned_to || "—").padEnd(10)}${R2} ` +
+        `${tc}${(t.model_tier || "—").padEnd(9)}${R2} ` +
+        `${DIM}${age.padEnd(6)}${R2}  ${title}`
+      );
+    };
+
+    if (active.length) {
+      active.forEach(t => printTask(t, "active"));
+    }
+    if (queue.length) {
+      queue.forEach(t => printTask(t, "queued"));
+    }
+    if (!active.length && !queue.length) {
+      lines.push(`  ${DIM}No tasks in queue or active.${R2}`);
+    }
+
+    lines.push(sep);
+    if (done.length) {
+      lines.push(`  ${DIM}Recently done:${R2}`);
+      done.forEach(t => printTask(t, "done"));
+    }
+
+    lines.push(`\n  ${DIM}queue: ${queue.length}  active: ${active.length}  done (total): ${readDir(path.join(swarmDir, "done")).length}${R2}\n`);
+
+    if (isTTY) process.stdout.write("\x1b[2J\x1b[H");
+    console.log(lines.join("\n"));
+  }
+
+  render();
+  const timer = setInterval(render, interval);
+
+  // Exit on 'q' or Ctrl+C
+  if (isTTY && process.stdin.setRawMode) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.once("data", (key) => {
+      clearInterval(timer);
+      process.stdin.setRawMode(false);
+      process.exit(0);
+    });
+  }
+  process.on("SIGINT", () => { clearInterval(timer); process.exit(0); });
+}
+
+module.exports = { cmdWatch };

package/lib/onboarding.js

@@ -0,0 +1,171 @@
+/**
+ * Onboarding helpers — post-install welcome, post-init checklist,
+ * first-status tip, time-to-init tracking.
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+// ---------------------------------------------------------------------------
+// State file
+// ---------------------------------------------------------------------------
+
+function _statePath(target) {
+  return path.join(target, "ai", ".0dai_state.json");
+}
+
+function _loadState(target) {
+  try {
+    return JSON.parse(fs.readFileSync(_statePath(target), "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function _saveState(target, state) {
+  try {
+    const dir = path.join(target, "ai");
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(_statePath(target), JSON.stringify(state, null, 2) + "\n");
+  } catch {}
+}
+
+// ---------------------------------------------------------------------------
+// Post-init What's Next
+// ---------------------------------------------------------------------------
+
+function showWhatsNext(mode, isAuthed) {
+  console.log("");
+  console.log("  \u2705 0dai initialized! Your AI agents are configured.");
+  console.log("");
+  console.log("  What's next:");
+  console.log("    \u2610 0dai status     \u2014 check your config");
+  console.log("    \u2610 0dai doctor     \u2014 verify everything works");
+  if (mode === "local" && !isAuthed) {
+    console.log("    \u2610 0dai auth login \u2014 sign in for full features (optional)");
+  } else if (mode === "cloud") {
+    console.log("    \u2610 0dai sync       \u2014 refresh configs from server");
+  }
+  console.log("");
+  console.log("  Pro features: 0dai upgrade");
+  console.log("");
+}
+
+// ---------------------------------------------------------------------------
+// First-status tip
+// ---------------------------------------------------------------------------
+
+function showFirstStatusTip(target) {
+  const state = _loadState(target);
+  if (state.first_status_shown) return;
+  console.log("");
+  console.log("  \ud83d\udca1 Tip: Run 0dai doctor to check config health");
+  state.first_status_shown = true;
+  _saveState(target, state);
+}
+
+// ---------------------------------------------------------------------------
+// Time-to-init tracking
+// ---------------------------------------------------------------------------
+
+function trackFirstRun(target) {
+  const state = _loadState(target);
+  if (!state.first_run_at) {
+    state.first_run_at = new Date().toISOString();
+    _saveState(target, state);
+  }
+}
+
+function trackFirstInit(target) {
+  const state = _loadState(target);
+  if (!state.first_init_at) {
+    state.first_init_at = new Date().toISOString();
+    _saveState(target, state);
+  }
+}
+
+function getTimeToInit(target) {
+  const state = _loadState(target);
+  if (!state.first_run_at || !state.first_init_at) return null;
+  const start = new Date(state.first_run_at).getTime();
+  const end = new Date(state.first_init_at).getTime();
+  if (isNaN(start) || isNaN(end)) return null;
+  return Math.round((end - start) / 1000);
+}
+
+// ---------------------------------------------------------------------------
+// Quickstart
+// ---------------------------------------------------------------------------
+
+async function cmdQuickstart(target, { cmdDoctor, cmdStatus, cmdInit, log, ensureAuthenticated }) {
+  const start = Date.now();
+  const steps = 5;
+
+  // Step 1: Auth
+  console.log(`\n  [1/${steps}] Checking authentication...`);
+  let authInfo = "not signed in";
+  try {
+    const auth = JSON.parse(fs.readFileSync(path.join(require("os").homedir(), ".0dai", "auth.json"), "utf8"));
+    if (auth.access_token) {
+      authInfo = `signed in (${auth.plan || "free"} plan)`;
+    }
+  } catch {}
+  console.log(`           \u2713 ${authInfo}`);
+
+  // Step 2: Init
+  console.log(`  [2/${steps}] Checking project config...`);
+  const aiExists = fs.existsSync(path.join(target, "ai", "VERSION"));
+  if (aiExists) {
+    console.log("           \u2713 ai/ layer found");
+  } else {
+    console.log("           initializing...");
+    try {
+      await cmdInit(target, ["--quickstart"]);
+      trackFirstInit(target);
+      console.log("           \u2713 project initialized");
+    } catch (err) {
+      console.log(`           \u2717 init failed: ${err.message || err}`);
+      console.log("           Run: 0dai init");
+    }
+  }
+
+  // Step 3: Doctor
+  console.log(`  [3/${steps}] Running health check...`);
+  if (fs.existsSync(path.join(target, "ai"))) {
+    try {
+      cmdDoctor(target);
+    } catch {}
+    console.log("           \u2713 health check complete");
+  } else {
+    console.log("           \u2717 skipped (no ai/ layer)");
+  }
+
+  // Step 4: Status
+  console.log(`  [4/${steps}] Project status:`);
+  if (fs.existsSync(path.join(target, "ai"))) {
+    try {
+      cmdStatus(target);
+    } catch {}
+  } else {
+    console.log("           (no project configured)");
+  }
+
+  // Step 5: Summary
+  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+  console.log(`  [5/${steps}] Ready! (${elapsed}s)`);
+  console.log("");
+  console.log("  Your project is set up. Try:");
+  console.log("    0dai swarm run --goal \"add auth\"  (Pro)");
+  console.log("    0dai graph push                   (Pro)");
+  console.log("");
+}
+
+module.exports = {
+  showWhatsNext,
+  showFirstStatusTip,
+  trackFirstRun,
+  trackFirstInit,
+  getTimeToInit,
+  cmdQuickstart,
+};