@0dai-dev/cli 2.6.0 → 2.9.0

package/bin/0dai.js

@@ -7,7 +7,7 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const VERSION = "2.6.0";
+const VERSION = "2.9.0";
 const API_URL = process.env.ODAI_API_URL || "https://api.0dai.dev";
 const T = process.stdout.isTTY ? "\x1b[38;2;45;212;168m" : ""; // teal
 const R = process.stdout.isTTY ? "\x1b[0m" : ""; // reset
@@ -145,7 +145,10 @@ function writeFiles(target, files) {
   return created + updated;
 }
 
-async function cmdInit(target) {
+async function cmdInit(target, args = []) {
+  const dryRun = args.includes("--dry-run");
+  const minimal = args.includes("--minimal");
+
   if (fs.existsSync(path.join(target, "ai", "VERSION"))) {
     const v = fs.readFileSync(path.join(target, "ai", "VERSION"), "utf8").trim();
     log(`ai/ layer already exists (v${v}). Run '0dai sync' to update.`);
@@ -159,12 +162,15 @@ async function cmdInit(target) {
   }
 
   const { projectFiles, fileContents, clis } = collectMetadata(target);
-  if (spinner) spinner.start(`Generating ai/ layer (${projectFiles.length} files, ${clis.length} CLIs)...`);
-  else log(`sending to API (${projectFiles.length} files, ${clis.length} CLIs)...`);
+  if (dryRun) log(`${D}dry-run: would generate ai/ layer (${projectFiles.length} files, ${clis.length} CLIs)${R}`);
+  if (spinner) spinner.start(`${dryRun ? "[dry-run] " : ""}Generating ai/ layer (${projectFiles.length} files, ${clis.length} CLIs)...`);
+  else if (!dryRun) log(`sending to API (${projectFiles.length} files, ${clis.length} CLIs)...`);
   const result = await apiCall("/v1/init", {
     project_files: projectFiles,
     file_contents: fileContents,
     available_clis: clis,
+    dry_run: dryRun,
+    minimal: minimal,
   });
 
   if (result.error) {
@@ -177,8 +183,15 @@ async function cmdInit(target) {
     process.exit(1);
   }
 
-  if (spinner) spinner.stop(`Detected: ${result.stack || "?"}`);
+  if (spinner) spinner.stop(`${dryRun ? "[dry-run] " : ""}Detected: ${result.stack || "?"}`);
   else log(`detected: ${result.stack || "?"}`);
+  if (dryRun) {
+    const files = Object.keys(result.files || {});
+    log(`${D}dry-run: would write ${files.length} files:${R}`);
+    for (const f of files.slice(0, 20)) console.log(`  ${D}+ ${f}${R}`);
+    if (files.length > 20) console.log(`  ${D}… and ${files.length - 20} more${R}`);
+    return;
+  }
   writeFiles(target, result.files || {});
 
   // Add to .gitignore
@@ -203,11 +216,14 @@ async function cmdInit(target) {
   console.log(`  ${D}0dai feedback push${R}`);
 }
 
-async function cmdSync(target) {
-  // Quick local check: skip API if already at current version
+async function cmdSync(target, args = []) {
+  const dryRun = args.includes("--dry-run");
+  const quiet = args.includes("--quiet") || args.includes("-q");
+
+  // Quick local check: skip API if already at current version (unless dry-run)
   let version = "unknown";
   try { version = fs.readFileSync(path.join(target, "ai", "VERSION"), "utf8").trim(); } catch {}
-  if (version === VERSION) {
+  if (!dryRun && version === VERSION) {
     log("already up to date (v" + version + ")");
     return;
   }
@@ -239,24 +255,57 @@ async function cmdSync(target) {
     walk(aiDir);
   }
 
+  if (dryRun) log(`${D}dry-run: checking what sync would change...${R}`);
+
   const result = await apiCall("/v1/sync", {
     ai_version: version, stack, agents: agents.length ? agents : clis,
     current_files: currentFiles, file_contents: fileContents,
+    dry_run: dryRun, quiet,
   });
 
   if (result.error) { log(`error: ${result.error}`); process.exit(1); }
 
   const updated = result.files_updated || {};
-  if (Object.keys(updated).length) writeFiles(target, updated);
-  else log("already up to date");
+  if (dryRun) {
+    const files = Object.keys(updated);
+    if (files.length) {
+      log(`${D}dry-run: would update ${files.length} file(s):${R}`);
+      for (const f of files) console.log(`  ${D}~ ${f}${R}`);
+    } else {
+      log(`${D}dry-run: nothing to update${R}`);
+    }
+    return;
+  }
+  const changedCount = Object.keys(updated).length;
+  if (changedCount) {
+    writeFiles(target, updated);
+    if (!quiet) {
+      for (const f of Object.keys(updated)) console.log(`  ~ ${f}`);
+    }
+    log(`sync: ${changedCount} file(s) updated`);
+  } else {
+    log("already up to date");
+  }
 }
 
 async function cmdDetect(target) {
+  const OPTIONAL_CLIS = ["gemini", "aider", "opencode"];
   const { projectFiles } = collectMetadata(target);
   const result = await apiCall("/v1/detect", { files: projectFiles });
   if (result.error) { log(`error: ${result.error}`); return; }
   console.log(`stack: ${result.stack || "?"}`);
-  console.log(`clis: ${(result.available_clis || []).join(",")}`);
+  const clis = result.available_clis || [];
+  if (clis.length) {
+    console.log(`clis:  ${clis.join(", ")}`);
+  } else {
+    console.log(`clis:  none detected`);
+    console.log(`       ${D}install claude, codex, or opencode to use 0dai${R}`);
+  }
+  // Explain optional CLIs so missing doesn't alarm users
+  const missing = OPTIONAL_CLIS.filter(c => !clis.includes(c));
+  if (missing.length && clis.length) {
+    console.log(`       ${D}optional (not installed): ${missing.join(", ")}${R}`);
+  }
 }
 
 function cmdAudit(target) {
@@ -427,13 +476,27 @@ function cmdDoctor(target) {
   let errors = 0, warnings = 0;
   log(`v${v} | stack: ${stack}\n`);
 
+  const missingConfigs = [];
   console.log("  ai/ layer:");
   for (const [name, { path: p, sev }] of Object.entries(layerChecks)) {
     const exists = fs.existsSync(p);
-    if (!exists) sev === "error" ? errors++ : warnings++;
+    if (!exists) {
+      sev === "error" ? errors++ : warnings++;
+      if (sev === "warn") missingConfigs.push(name);
+    }
     const mark = exists ? `${G}ok${R2}` : sev === "error" ? `${E}MISSING${R2}` : `${W}missing${R2}`;
     console.log(`    ${mark.padEnd(22)} ${name}`);
   }
+  // Explain WHY native configs are missing and what to do
+  if (missingConfigs.length > 0) {
+    const hasDiscovery = fs.existsSync(path.join(ai, "manifest", "discovery.json"));
+    if (hasDiscovery) {
+      console.log(`\n    ${W}→ Native configs not generated yet.${R2}`);
+      console.log(`      ${D}Run: 0dai sync --target .${R2}`);
+    } else {
+      console.log(`\n    ${W}→ ai/ layer incomplete — run '0dai init' first.${R2}`);
+    }
+  }
 
   console.log("\n  credentials:");
   for (const c of credChecks) {
@@ -458,6 +521,50 @@ function cmdDoctor(target) {
   if (errors) process.exitCode = 1;
 }
 
+function cmdValidate(target) {
+  const ai = path.join(target, "ai");
+  if (!fs.existsSync(ai)) {
+    log("no ai/ layer. Run '0dai init' first.");
+    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 = {
+    codex: ["AGENTS.md", ".codex/config.toml"],
+    claude: [".claude/settings.json", ".claude/CLAUDE.md", ".mcp.json"],
+    opencode: ["opencode.json"],
+  };
+  for (const agent of agents) {
+    for (const f of agentFiles[agent] || []) required.push(f);
+  }
+
+  const missing = required.filter(f => !fs.existsSync(path.join(target, f)));
+  if (missing.length) {
+    log(`Validation FAILED: ${missing.length} missing file(s)\n`);
+    for (const f of missing) console.log(`  ${E}✗${R2} ${f}`);
+    console.log(`\n  ${D2}Run: 0dai sync --target . to fix missing files${R2}`);
+    process.exitCode = 1;
+  } else {
+    log(`${G}validate ok${R2} — all required files present`);
+  }
+}
+
 // --- Session reflection --- (dogfood feedback #36)
 function cmdReflect(target, args) {
   const ai = path.join(target, "ai");
@@ -526,15 +633,77 @@ function cmdReflect(target, args) {
   if (totalPending) console.log(`  ${B}Remaining${R2}  ${W}${totalPending}${R2} tasks still pending`);
   if (successRate !== null) console.log(`  ${B}Rate${R2}       ${successRate >= 80 ? G : W}${successRate}%${R2} delegation success rate`);
 
-  // By agent breakdown
+  // By agent breakdown with per-agent completion rate
+  const allPendingByAgent = {};
+  for (const t of [...allQueue, ...allActive]) {
+    const a = t.assigned_to || "unknown";
+    allPendingByAgent[a] = (allPendingByAgent[a] || 0) + 1;
+  }
+
   if (Object.keys(byAgent).length) {
     console.log(`\n  ${B}By agent:${R2}`);
     for (const [agent, data] of Object.entries(byAgent).sort((a, b) => b[1].done - a[1].done)) {
+      const pending = allPendingByAgent[agent] || 0;
+      const total = data.done + pending;
+      const rate = total > 0 ? Math.round((data.done / total) * 100) : 100;
       const bar = "█".repeat(Math.min(data.done, 20));
-      console.log(`    ${(agent + " ").padEnd(14)} ${G}${bar}${R2} ${data.done}`);
+      const rateStr = total > 1 ? ` (${rate >= 80 ? G : W}${rate}%${R2})` : "";
+      console.log(`    ${(agent + " ").padEnd(14)} ${G}${bar}${R2} ${data.done}/${total}${rateStr}`);
+    }
+    // Agents with only pending tasks (never completed anything in window)
+    for (const [agent, count] of Object.entries(allPendingByAgent)) {
+      if (!byAgent[agent]) {
+        console.log(`    ${(agent + " ").padEnd(14)} ${W}${"░".repeat(Math.min(count, 20))}${R2} 0/${count} ${W}(pending)${R2}`);
+      }
     }
   }
 
+  // Budget summary from budget.json
+  const budgetFile = path.join(ai, "swarm", "budget.json");
+  try {
+    const budget = JSON.parse(fs.readFileSync(budgetFile, "utf8"));
+    const today = new Date().toISOString().slice(0, 10);
+    const sessionKey = process.env.ODAI_SESSION_ID ||
+      new Date().toISOString().slice(0, 13).replace("T", "-"); // YYYY-MM-DD-HH
+    const dailySpent = budget.daily?.[today] || 0;
+    const totalSpent = budget.total_spent || 0;
+    const sess = budget.sessions?.[sessionKey];
+
+    // Tier distribution across all tasks
+    const tierCount = { fast: 0, balanced: 0, deep: 0 };
+    for (const t of Object.values(budget.tasks || {})) {
+      if (t.tier && tierCount[t.tier] !== undefined) tierCount[t.tier]++;
+    }
+    const tieredTotal = tierCount.fast + tierCount.balanced + tierCount.deep;
+
+    if (dailySpent > 0 || totalSpent > 0 || sess) {
+      console.log(`\n  ${B}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(`    ${B}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(`    ${D}Tiers          ${tiers}${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 ? G : pct < 80 ? W : "\x1b[31m";
+        console.log(`    ${B}Today${R2}         ${col}$${dailySpent.toFixed(4)}${R2} / $${dailyLimit.toFixed(2)} ${D}${bar} ${pct}%${R2}`);
+      }
+      if (totalSpent > 0) {
+        console.log(`    ${B}All time${R2}      ${D}$${totalSpent.toFixed(4)}${R2}`);
+      }
+      if (tieredTotal > 0) {
+        const fastPct = Math.round((tierCount.fast / tieredTotal) * 100);
+        console.log(`    ${D}Model routing  ${tierCount.fast}×fast  ${tierCount.balanced}×balanced  ${tierCount.deep}×deep  (${fastPct}% cheap)${R2}`);
+      }
+    }
+  } catch {}
+
   // Remaining blockers
   if (allQueue.length) {
     console.log(`\n  ${B}Blockers / queue:${R2}`);
@@ -554,6 +723,146 @@ function cmdReflect(target, args) {
   console.log();
 }
 
+function cmdMetrics(target) {
+  const ai = path.join(target, "ai");
+  const G = "\x1b[32m", W = "\x1b[33m", R2 = "\x1b[0m", D = "\x1b[2m",
+        B = "\x1b[34m", T = "\x1b[36m", M = "\x1b[35m";
+
+  // --- Data sources ---
+  let stats = {}, budget = {}, discovery = {};
+  try { stats  = JSON.parse(fs.readFileSync(path.join(ai, "feedback", ".usage_stats.json"), "utf8")); } catch {}
+  try { budget = JSON.parse(fs.readFileSync(path.join(ai, "swarm", "budget.json"), "utf8")); } catch {}
+  try { discovery = JSON.parse(fs.readFileSync(path.join(ai, "manifest", "discovery.json"), "utf8")); } catch {}
+
+  const projectName = discovery.project_name || path.basename(target);
+  const stack = discovery.stack || "?";
+  const totalSessions = stats.total_sessions || 0;
+  const agentBreakdown = stats.agents || {};
+  const layerInfo = stats.layer || {};
+  const lastSession = stats.last_session ? new Date(stats.last_session) : null;
+  const layerVersion = stats.version || "?";
+
+  // Swarm tasks: count done files
+  let tasksDone = 0, tasksQueue = 0;
+  const doneDir = path.join(ai, "swarm", "done");
+  const queueDir = path.join(ai, "swarm", "queue");
+  try { tasksDone = fs.readdirSync(doneDir).filter(f => f.endsWith(".json")).length; } catch {}
+  try { tasksQueue = fs.readdirSync(queueDir).filter(f => f.endsWith(".json")).length; } catch {}
+
+  // Activity: count events from activity.jsonl
+  let activityEvents = 0;
+  try {
+    const lines = fs.readFileSync(path.join(ai, "swarm", "activity.jsonl"), "utf8").trim().split("\n").filter(Boolean);
+    activityEvents = lines.length;
+  } catch {}
+
+  // Feedback submissions
+  let feedbackCount = layerInfo.feedback_reports || 0;
+
+  // Budget totals
+  const totalSpent = budget.total_spent || 0;
+  const sessionsWithBudget = Object.keys(budget.sessions || {}).length;
+
+  // --- Effectiveness score (0-100) ---
+  let score = 0, scoreNotes = [];
+
+  // Sessions depth: 1 = tried, 3 = habit forming, 7 = regular use
+  const sessionScore = Math.min(Math.floor((totalSessions / 7) * 35), 35);
+  score += sessionScore;
+  if (totalSessions === 0)       scoreNotes.push("not started");
+  else if (totalSessions === 1)  scoreNotes.push("first session");
+  else if (totalSessions < 3)    scoreNotes.push("early");
+  else if (totalSessions < 7)    scoreNotes.push("habit forming");
+  else                           scoreNotes.push("regular use");
+
+  // Delegation: did they delegate to swarm?
+  const delegationScore = tasksDone > 0 ? Math.min(Math.floor((tasksDone / 5) * 30), 30) : 0;
+  score += delegationScore;
+  if (tasksDone > 0) scoreNotes.push(`${tasksDone} tasks delegated`);
+
+  // Feedback: submitted = trust signal
+  const feedbackScore = feedbackCount > 0 ? 20 : 0;
+  score += feedbackScore;
+  if (feedbackCount > 0) scoreNotes.push("feedback submitted");
+
+  // Layer completeness: has playbooks and commands?
+  const layerScore = (layerInfo.playbooks && layerInfo.commands) ? 15 : (layerInfo.commands ? 8 : 0);
+  score += layerScore;
+
+  const scoreColor = score >= 70 ? G : score >= 40 ? W : "\x1b[31m";
+  const bar = "█".repeat(Math.round(score / 5)).padEnd(20, "░");
+
+  // --- Output ---
+  console.log(`\n  ${T}Metrics${R2}  ${D}${projectName} · ${stack} · ai v${layerVersion}${R2}\n`);
+
+  // Effectiveness score
+  console.log(`  ${B}Effectiveness${R2}`);
+  console.log(`    ${scoreColor}${score}/100${R2}  ${D}${bar}${R2}`);
+  if (scoreNotes.length) console.log(`    ${D}${scoreNotes.join("  ·  ")}${R2}`);
+
+  // Adoption funnel
+  console.log(`\n  ${B}Adoption funnel${R2}`);
+  const funnelStep = (label, value, done, hint) => {
+    const icon = done ? `${G}✓${R2}` : `${D}○${R2}`;
+    const val = value !== null ? `  ${D}${value}${R2}` : "";
+    const h = !done && hint ? `  ${D}← ${hint}${R2}` : "";
+    console.log(`    ${icon}  ${label}${val}${h}`);
+  };
+  funnelStep("Initialized",       `ai/ v${layerVersion}`,    true);
+  funnelStep("Returned (>1 session)",  `${totalSessions} total`,  totalSessions > 1, "run 0dai reflect after each session");
+  funnelStep("Used swarm delegation",  tasksDone > 0 ? `${tasksDone} tasks done` : null, tasksDone > 0, "try: 0dai swarm add --task '...' --to codex");
+  funnelStep("Submitted feedback",     feedbackCount > 0 ? `${feedbackCount} reports` : null, feedbackCount > 0, "0dai feedback log + push");
+
+  // Session stats
+  if (totalSessions > 0) {
+    console.log(`\n  ${B}Sessions${R2}`);
+    console.log(`    Total      ${totalSessions}`);
+    if (lastSession) {
+      const daysAgo = Math.floor((Date.now() - lastSession.getTime()) / 86400000);
+      const when = daysAgo === 0 ? "today" : daysAgo === 1 ? "yesterday" : `${daysAgo}d ago`;
+      console.log(`    Last       ${when}`);
+    }
+    const agentEntries = Object.entries(agentBreakdown).sort((a, b) => b[1] - a[1]);
+    if (agentEntries.length) {
+      console.log(`    Agents     ${agentEntries.map(([a, n]) => `${a}: ${n}`).join("  ")}`);
+    }
+    if (sessionsWithBudget > 0 && totalSpent > 0) {
+      console.log(`    Cost       $${totalSpent.toFixed(4)} total  ${D}(${sessionsWithBudget} sessions tracked)${R2}`);
+    }
+  }
+
+  // Delegation stats
+  if (tasksDone > 0 || tasksQueue > 0) {
+    console.log(`\n  ${B}Delegation${R2}`);
+    if (tasksDone > 0) console.log(`    Done       ${G}${tasksDone}${R2}`);
+    if (tasksQueue > 0) console.log(`    Queue      ${W}${tasksQueue}${R2}`);
+    if (activityEvents > 0) console.log(`    Events     ${activityEvents}`);
+  }
+
+  // Layer health
+  console.log(`\n  ${B}ai/ layer${R2}`);
+  const checks = [
+    ["commands.yaml",  layerInfo.commands],
+    ["playbooks",      layerInfo.playbooks],
+    ["personas",       layerInfo.personas],
+    ["session roaming", layerInfo.session_active],
+    ["swarm queue",    (layerInfo.swarm_queue || 0) > 0],
+  ];
+  for (const [label, ok] of checks) {
+    const icon = ok ? `${G}✓${R2}` : `${D}—${R2}`;
+    console.log(`    ${icon}  ${label}`);
+  }
+
+  // Next suggested action
+  console.log(`\n  ${B}Next${R2}`);
+  if (totalSessions === 0)   console.log(`    ${D}Start a Claude Code session — session_start hook will print project context${R2}`);
+  else if (tasksDone === 0)  console.log(`    ${D}Try delegating a task: 0dai swarm add --task "write tests for auth module" --to codex${R2}`);
+  else if (feedbackCount === 0) console.log(`    ${D}Submit feedback: 0dai feedback log --type positive --detail "what worked"${R2}`);
+  else                       console.log(`    ${D}Score ${score}/100 — keep delegating and submitting feedback${R2}`);
+
+  console.log();
+}
+
 function cmdStatus(target) {
   const ai = path.join(target, "ai");
   let v = "?", stack = "?";
@@ -722,6 +1031,33 @@ function cmdAuthLogout() {
   log("Logged out");
 }
 
+async function cmdRedeem(code) {
+  if (!code) {
+    console.log("Usage: 0dai redeem <CODE>");
+    console.log("Example: 0dai redeem ESSE-ABCD-1234");
+    process.exit(1);
+  }
+  try {
+    JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+  } catch {
+    log("Not logged in. Run: 0dai auth login");
+    process.exit(1);
+  }
+  log(`Redeeming code ${T}${code.toUpperCase()}${R}...`);
+  const result = await apiCall("/v1/redeem", { code: code.toUpperCase().trim() });
+  if (result.ok) {
+    log(`${T}✓${R} ${result.message}`);
+    if (result.duration_days) {
+      log(`  Plan active for ${result.duration_days} days`);
+    }
+    log(`  Run ${D}0dai auth status${R} to see updated limits`);
+  } else {
+    log(`error: ${result.error || "unknown"}`);
+    if (result.hint) log(`hint: ${result.hint}`);
+    process.exit(1);
+  }
+}
+
 async function cmdAuthStatus() {
   try {
     const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
@@ -949,7 +1285,59 @@ function cmdSwarm(target, sub, args) {
     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"));
-    log(`total: $${(b.total_spent || 0).toFixed(4)} (${Object.keys(b.tasks || {}).length} tasks)`);
+    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]");
@@ -1002,11 +1390,13 @@ async function main() {
 
   switch (cmd) {
     case "audit": cmdAudit(target); break;
-    case "init": await cmdInit(target); break;
-    case "sync": await cmdSync(target); break;
+    case "init": await cmdInit(target, args); break;
+    case "sync": await cmdSync(target, args); break;
     case "detect": await cmdDetect(target); break;
     case "doctor": cmdDoctor(target); break;
+    case "validate": cmdValidate(target); break;
     case "reflect": cmdReflect(target, args); break;
+    case "metrics": cmdMetrics(target); break;
     case "status": cmdStatus(target); break;
     case "auth":
       if (sub === "login") await cmdAuthLogin();
@@ -1020,6 +1410,7 @@ async function main() {
     case "swarm": cmdSwarm(target, sub, args); break;
     case "feedback": await cmdFeedback(target, sub, args); break;
     case "models": cmdModels(sub || args[1]); break;
+    case "redeem": await cmdRedeem(sub || args[1]); break;
     case "terminal": case "term":
       try {
         const SessionManager = require("../lib/session-manager");
@@ -1046,11 +1437,13 @@ async function main() {
       console.log(`\n  ${T}0dai${R} v${VERSION} — One config for 5 AI agent CLIs\n`);
       console.log("Commands:");
       console.log("  audit          Scan ai/ and agent configs for leaked secrets");
-      console.log("  init           Initialize ai/ layer (via API)");
-      console.log("  sync           Update ai/ layer (via API)");
+      console.log("  init           Initialize ai/ layer (via API) [--dry-run] [--minimal]");
+      console.log("  sync           Update ai/ layer (via API) [--dry-run] [--quiet]");
       console.log("  detect         Show detected stack");
       console.log("  doctor         Check health + credentials checklist");
+  console.log("  validate       Validate ai/ layer completeness");
       console.log("  reflect        Session reflection: delivered, delegation rate, blockers");
+      console.log("  metrics        Effectiveness score: adoption funnel, sessions, delegation");
       console.log("  status         Show maturity, swarm, session");
       console.log("  session save   Save session for roaming");
       console.log("  swarm status       Task queue & delegation");
@@ -1063,6 +1456,7 @@ async function main() {
       console.log("  auth login     Authenticate (device code flow)");
       console.log("  auth logout    Remove credentials");
       console.log("  auth status    Show account and usage");
+      console.log("  redeem <CODE>  Redeem a plan upgrade code");
       console.log("  --version\n");
       console.log("https://0dai.dev");
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0dai-dev/cli",
-  "version": "2.6.0",
+  "version": "2.9.0",
   "description": "One config layer for 5 AI agent CLIs — Claude Code, Codex, OpenCode, Gemini, Aider",
   "bin": {
     "0dai": "./bin/0dai.js"