@0dai-dev/cli 3.10.1 → 4.1.0

package/lib/commands/session.js

@@ -0,0 +1,61 @@
+"use strict";
+const shared = require("../shared");
+const { log, fs, path, requirePlan } = shared;
+
+function cmdSession(target, sub, args) {
+  const sessFile = path.join(target, "ai", "sessions", "active.json");
+  const sessDir = path.dirname(sessFile);
+
+  if (sub === "save") {
+    const gate = requirePlan("pro", "Session Roaming", target);
+    if (gate) {
+      log(gate.error);
+      log(gate.hint);
+      return;
+    }
+    fs.mkdirSync(sessDir, { recursive: true });
+    const goal = args.find((_, i) => args[i - 1] === "--goal") || "";
+    const summary = args.find((_, i) => args[i - 1] === "--summary") || "";
+    const session = {
+      id: `sess-${Date.now()}`,
+      started: new Date().toISOString(),
+      current_agent: "cli",
+      task: { goal: goal || summary || "active session", status: "in_progress" },
+      handoff_notes: summary,
+      context: { files_touched: [] },
+    };
+    if (fs.existsSync(sessFile)) {
+      const existing = JSON.parse(fs.readFileSync(sessFile, "utf8"));
+      existing.handoff_notes = summary || existing.handoff_notes;
+      if (goal) existing.task.goal = goal;
+      existing.updated = new Date().toISOString();
+      fs.writeFileSync(sessFile, JSON.stringify(existing, null, 2));
+      log("session updated");
+    } else {
+      fs.writeFileSync(sessFile, JSON.stringify(session, null, 2));
+      log(`session started: ${session.id}`);
+    }
+    return;
+  }
+  if (sub === "status") {
+    if (!fs.existsSync(sessFile)) { log("no active session"); return; }
+    const s = JSON.parse(fs.readFileSync(sessFile, "utf8"));
+    log(`session: ${(s.task || {}).goal || "?"}`);
+    console.log(`  agent: ${s.current_agent || "?"}`);
+    if (s.handoff_notes) console.log(`  handoff: ${s.handoff_notes}`);
+    return;
+  }
+  if (sub === "complete") {
+    if (!fs.existsSync(sessFile)) { log("no active session"); return; }
+    const archiveDir = path.join(target, "ai", "sessions", "archive");
+    fs.mkdirSync(archiveDir, { recursive: true });
+    const s = JSON.parse(fs.readFileSync(sessFile, "utf8"));
+    fs.writeFileSync(path.join(archiveDir, `${s.id || "session"}.json`), JSON.stringify(s, null, 2));
+    fs.unlinkSync(sessFile);
+    log(`session ${s.id} archived`);
+    return;
+  }
+  console.log("Usage: 0dai session [save|status|complete] [--goal '...'] [--summary '...']");
+}
+
+module.exports = { cmdSession };

package/lib/commands/status.js

@@ -0,0 +1,69 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, spawnSync, findRepoScript, getSwarmQuotaLocal, _detectPlanLocal, PLAN_LEVELS } = shared;
+
+function cmdStatus(target) {
+  const ai = path.join(target, "ai");
+  let v = "?", stack = "?";
+  try { v = fs.readFileSync(path.join(ai, "VERSION"), "utf8").trim(); } catch {}
+  try { stack = JSON.parse(fs.readFileSync(path.join(ai, "manifest", "discovery.json"), "utf8")).stack || "?"; } catch {}
+  log(`v${v} | stack: ${stack}`);
+
+  const count = (dir) => { try { return fs.readdirSync(dir).filter(f => f.endsWith(".json")).length; } catch { return 0; } };
+  const q = count(path.join(ai, "swarm", "queue"));
+  const a = count(path.join(ai, "swarm", "active"));
+  const d = count(path.join(ai, "swarm", "done"));
+  if (q || a || d) console.log(`  swarm: ${q} queued, ${a} active, ${d} done`);
+
+  // Swarm quota
+  const quota = getSwarmQuotaLocal(target);
+  if (quota.plan === "free") {
+    console.log(`  swarm quota: ${D}locked (Free) — upgrade for ${quota.daily_limit} tasks/day${R}`);
+  } else {
+    console.log(`  swarm quota: ${quota.used_today}/${quota.daily_limit} tasks today (${quota.plan})`);
+  }
+
+  // Session roaming status
+  const sessPlan = _detectPlanLocal(target);
+  const sessLocked = PLAN_LEVELS[sessPlan] < PLAN_LEVELS["pro"];
+  if (sessLocked) {
+    console.log(`  session roaming: ${D}locked (Free) — upgrade to save/resume sessions${R}`);
+  } else {
+    console.log(`  session roaming: ${T}available (${sessPlan})${R}`);
+  }
+
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(ai, "sessions", "active.json"), "utf8"));
+    console.log(`  session: ${(s.task || {}).goal || "?"} (agent: ${s.current_agent || "?"})`);
+  } catch {}
+
+  // Anti-pattern warnings count
+  try {
+    const ds = findRepoScript(target, "anti_pattern_detector.py");
+    if (ds) {
+      const wr = spawnSync("python3", [ds, "count", "--target", target],
+                           { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8", timeout: 5000 });
+      if (wr.status === 0 && wr.stdout) {
+        const wc = JSON.parse(wr.stdout.trim());
+        if (wc.count > 0) console.log(`  warnings: ${wc.count} active — run: 0dai experience warnings`);
+      }
+    }
+  } catch {}
+
+  // First-status tip (shows once after init)
+  try { require("../onboarding").showFirstStatusTip(target); } catch {}
+
+  // Drift warning (lightweight)
+  try {
+    const ds = findRepoScript(target, "drift_detector.py");
+    if (ds) {
+      const dr = spawnSync("python3", [ds, "report", "--target", target],
+                           { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8", timeout: 5000 });
+      if (dr.stdout && (dr.stdout.includes("MODIFIED") || dr.stdout.includes("CONTRADICTS"))) {
+        console.log(`  drift: config changes detected — run: 0dai doctor --drift`);
+      }
+    }
+  } catch {}
+}
+
+module.exports = { cmdStatus };

package/lib/commands/swarm.js

@@ -0,0 +1,199 @@
+"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;
+  }
+  if (sub === "estimate") {
+    const gate = requirePlan("pro", "Swarm Estimate", target);
+    if (gate) { log(gate.error); log(gate.hint); return; }
+    const goal = args.find((_, i) => args[i - 1] === "--goal") || "";
+    if (!goal) { console.log("Usage: 0dai swarm estimate --goal '...' [--agent claude|codex] [--model tier] [--json]"); return; }
+    const agent = args.find((_, i) => args[i - 1] === "--agent") || "";
+    const model = args.find((_, i) => args[i - 1] === "--model") || "";
+    const asJson = args.includes("--json");
+    // Call API for cost estimate
+    const identity = shared.buildProjectIdentity(target, shared.collectMetadata(target));
+    shared.apiCall("/v1/swarm/estimate", { goal, agent, model_tier: model, project_id: identity.project_id }).then((result) => {
+      if (result.error) { log(`error: ${result.error}`); return; }
+      if (asJson) { console.log(JSON.stringify(result, null, 2)); return; }
+      log(`Cost estimate for: ${goal}`);
+      console.log(`  ${D}Estimated: $${(result.estimated_cost_usd || 0).toFixed(4)} · ${result.estimated_tokens || "?"} tokens · ${result.estimated_time_s || "?"}s${R}`);
+      if (result.model_recommendation) console.log(`  ${T}Recommended: ${result.model_recommendation}${R}`);
+      if (result.tier_breakdown) {
+        for (const [tier, cost] of Object.entries(result.tier_breakdown)) {
+          console.log(`    ${tier}: $${cost.toFixed(4)}`);
+        }
+      }
+    });
+    return;
+  }
+  if (sub === "quality") {
+    const scorerScript = findRepoScript(target, "quality_scorer.py");
+    if (!scorerScript) { log("quality scorer unavailable"); return; }
+    const fwd = [scorerScript, "--target", target];
+    if (args.includes("--json")) fwd.push("--json");
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === "--last" && args[i + 1]) { fwd.push("--last", args[i + 1]); i++; }
+      else if (args[i] === "--details" && args[i + 1]) { fwd.push("--details", args[i + 1]); i++; }
+    }
+    const result = spawnSync("python3", fwd, { stdio: "inherit", timeout: 15000 });
+    if (typeof result.status === "number" && result.status !== 0) process.exit(result.status);
+    return;
+  }
+  console.log("Usage: 0dai swarm [status|add|delegate|budget|estimate|quality] [--task '...'] [--to agent]");
+  console.log("  quality   Show quality scores for recent tasks (--last N / --details TASK_ID)");
+}
+
+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 };