@0dai-dev/cli 3.10.1 → 4.1.0

package/lib/commands/metrics.js

@@ -0,0 +1,145 @@
+"use strict";
+const shared = require("../shared");
+const { fs, path } = shared;
+
+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();
+}
+
+module.exports = { cmdMetrics };

package/lib/commands/models.js

@@ -0,0 +1,90 @@
+"use strict";
+const shared = require("../shared");
+const { T, R } = shared;
+
+function cmdModels(filter) {
+  // Scores from benchmark_models.py (3-task: read/count/review, 2026-04-06)
+  const MODELS = [
+    { name: "Claude Opus 4.6",   tier: "deep",     score: 95, cli: "claude",   flag: "--model opus" },
+    { name: "GPT-5.4-mini",      tier: "fast",     score: 93, cli: "codex",    flag: "-m gpt-5.4-mini",      tested: true },
+    { name: "MiniMax M2.7",      tier: "balanced", score: 93, cli: "opencode", flag: "-m opencode-go/minimax-m2.7",   tested: true },
+    { name: "Claude Sonnet 4.6", tier: "balanced", score: 90, cli: "claude",   flag: "--model sonnet" },
+    { name: "GPT-5.4",           tier: "balanced", score: 90, cli: "codex",    flag: "-m gpt-5.4",           tested: true },
+    { name: "Kimi K2.5",         tier: "balanced", score: 88, cli: "opencode", flag: "-m opencode-go/kimi-k2.5",      tested: true },
+    { name: "Qwen 3.6+ Free",    tier: "free",     score: 88, cli: "opencode", flag: "-m opencode/qwen3.6-plus-free", tested: true },
+    { name: "Gemini 3.1 Pro",    tier: "balanced", score: 85, cli: "gemini",   flag: "-m gemini-3.1-pro" },
+    { name: "GPT-5.3 Codex",     tier: "deep",     score: 83, cli: "codex",    flag: "-m gpt-5.3-codex",      tested: true },
+    { name: "GPT-5.3 Spark",     tier: "fast",     score: 82, cli: "codex",    flag: "-m gpt-5.3-codex-spark" },
+    { name: "Claude Haiku 4.5",  tier: "fast",     score: 78, cli: "claude",   flag: "--model haiku" },
+    { name: "Gemini 3 Flash",    tier: "fast",     score: 77, cli: "gemini",   flag: "-m gemini-3-flash" },
+    { name: "Mimo v2 Pro",       tier: "fast",     score: 74, cli: "opencode", flag: "-m opencode-go/mimo-v2-pro",    tested: true },
+    { name: "GPT-5.4 (opencode)",tier: "fast",     score: 74, cli: "opencode", flag: "-m openai/gpt-5.4",            tested: true },
+    { name: "GPT-5.2",           tier: "balanced", score: 87, cli: "codex",    flag: "-m gpt-5.2",           tested: true },
+    { name: "MiniMax M2.5",      tier: "slow",     score: 57, cli: "opencode", flag: "-m opencode-go/minimax-m2.5",   tested: true },
+  ];
+
+  const { execFileSync } = require("child_process");
+  const available = new Set();
+  for (const cli of ["claude", "codex", "opencode", "gemini", "aider"]) {
+    try { execFileSync("/bin/sh", ["-c", `command -v ${cli}`], { stdio: "ignore" }); available.add(cli); } catch {}
+  }
+
+  const isTTY = process.stdout.isTTY;
+  const Y  = isTTY ? "\x1b[33m" : "";
+  const G  = isTTY ? "\x1b[32m" : "";
+  const DIM = isTTY ? "\x1b[2m" : "";
+
+  let models = [...MODELS].sort((a, b) => b.score - a.score);
+  if (filter === "--fast")      models = models.filter(m => m.tier === "fast");
+  if (filter === "--balanced")  models = models.filter(m => m.tier === "balanced");
+  if (filter === "--deep")      models = models.filter(m => m.tier === "deep");
+  if (filter === "--available") models = models.filter(m => available.has(m.cli));
+
+  const tc = (t) => t === "deep" ? T : t === "balanced" ? G : DIM;
+  console.log(`\n  ${T}0dai${R} model ratings — ${models.length} models\n`);
+  console.log(`  ${"SCORE".padEnd(6)} ${"MODEL".padEnd(22)} ${"TIER".padEnd(10)} ${"CLI".padEnd(10)} FLAG`);
+  console.log(`  ${"-".repeat(64)}`);
+  for (const m of models) {
+    const dim = available.has(m.cli) ? "" : DIM;
+    const mark = m.tested ? ` ${G}✓${R}` : "";
+    console.log(`${dim}  ${Y}${String(m.score).padEnd(6)}${R} ${m.name.padEnd(22)} ${tc(m.tier)}${m.tier.padEnd(10)}${R} ${m.cli.padEnd(10)} ${DIM}${m.flag}${R}${mark}${dim ? R : ""}`);
+  }
+  console.log(`\n  ${DIM}✓ = swarm-benchmarked  |  dimmed = CLI not installed${R}`);
+  console.log(`  ${DIM}Filter: --fast  --balanced  --deep  --available${R}`);
+  console.log(`  ${DIM}Full table: https://0dai.dev/models${R}\n`);
+}
+
+async function cmdModelsRecommend(target, args) {
+  const shared = require("../shared");
+  const { log, T, R, D, findRepoScript, spawnSync, requirePlan } = shared;
+
+  const gate = requirePlan("pro", "Model Recommend", target);
+  if (gate) { log(gate.error); log(gate.hint); return; }
+
+  const taskType = args.find((_, i) => args[i - 1] === "--task") || "";
+  const goal = args.find((_, i) => args[i - 1] === "--goal") || "";
+  const maxCost = parseFloat(args.find((_, i) => args[i - 1] === "--max-cost") || "0");
+  const minQuality = parseFloat(args.find((_, i) => args[i - 1] === "--min-quality") || "0");
+  const asJson = args.includes("--json");
+
+  if (!taskType && !goal) {
+    console.log("Usage: 0dai models recommend --task TYPE [--goal '...'] [--max-cost N] [--min-quality N] [--json]");
+    console.log("  TYPE: feat, fix, refactor, test, docs");
+    return;
+  }
+
+  const recScript = findRepoScript(target, "model_router.py");
+  if (!recScript) { log("model router unavailable"); return; }
+
+  const fwd = [recScript, "recommend", "--target", target];
+  if (taskType) fwd.push("--task", taskType);
+  if (goal) fwd.push("--goal", goal);
+  if (maxCost > 0) fwd.push("--max-cost", String(maxCost));
+  if (minQuality > 0) fwd.push("--min-quality", String(minQuality));
+  if (asJson) fwd.push("--json");
+
+  const result = spawnSync("python3", fwd, { stdio: "inherit" });
+  if (typeof result.status === "number" && result.status !== 0) process.exit(result.status);
+}
+
+module.exports = { cmdModels, cmdModelsRecommend };

package/lib/commands/portfolio.js

@@ -0,0 +1,96 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, PROJECTS_FILE } = shared;
+
+function cmdPortfolio() {
+  let projects = [];
+  try { projects = JSON.parse(fs.readFileSync(PROJECTS_FILE, "utf8")).projects || []; } catch {}
+
+  if (!projects.length) {
+    log(`no projects registered yet`);
+    console.log(`  Run ${D}0dai init${R} in a project to start tracking it.`);
+    return;
+  }
+
+  const rows = [];
+  let totalSessions = 0, totalScore = 0, scored = 0;
+
+  for (const p of projects) {
+    if (!fs.existsSync(p.path)) continue;
+
+    let sessions = 0, lastSession = null, agentMap = {};
+    try {
+      const stats = JSON.parse(fs.readFileSync(path.join(p.path, "ai", "feedback", ".usage_stats.json"), "utf8"));
+      sessions = stats.total_sessions || 0;
+      lastSession = stats.last_session || null;
+      agentMap = stats.agents || {};
+    } catch {}
+
+    let name = p.name, stack = p.stack;
+    try {
+      const disc = JSON.parse(fs.readFileSync(path.join(p.path, "ai", "manifest", "discovery.json"), "utf8"));
+      name = disc.project_name || name;
+      stack = disc.stack || stack;
+    } catch {}
+
+    // Effectiveness score (mirrors metrics command)
+    let score = 0;
+    if (sessions > 0) {
+      score += Math.min(sessions * 5, 35);
+      let done = 0;
+      try { done = fs.readdirSync(path.join(p.path, "ai", "swarm", "done")).filter(f => f.endsWith(".json")).length; } catch {}
+      if (done > 0) score += Math.min(done * 6, 30);
+      try {
+        const hasFb = fs.readdirSync(path.join(p.path, "ai", "feedback")).some(f => f.endsWith("-report.json"));
+        if (hasFb) score += 20;
+      } catch {}
+      const layerFiles = ["ai/manifest/discovery.json", "ai/manifest/commands.yaml", "ai/playbooks/quick-start.md"];
+      score += Math.round(layerFiles.filter(f => fs.existsSync(path.join(p.path, f))).length / layerFiles.length * 15);
+    }
+
+    totalSessions += sessions;
+    if (sessions > 0) { totalScore += score; scored++; }
+
+    const agentList = Object.keys(agentMap).join("·") || "—";
+
+    let ago = "never";
+    if (lastSession) {
+      const h = Math.floor((Date.now() - new Date(lastSession).getTime()) / 3600000);
+      const d = Math.floor(h / 24);
+      if (h < 1) ago = "<1h ago";
+      else if (h < 24) ago = `${h}h ago`;
+      else if (d < 7) ago = `${d}d ago`;
+      else ago = `${Math.floor(d / 7)}w ago`;
+    }
+
+    rows.push({ name, stack, score: sessions > 0 ? score : null, sessions, agents: agentList, ago });
+  }
+
+  if (!rows.length) {
+    log("no projects found (paths may have moved)");
+    return;
+  }
+
+  const nameW = Math.min(Math.max(...rows.map(r => r.name.length), 4), 28);
+  const stackW = Math.min(Math.max(...rows.map(r => r.stack.length), 5), 16);
+
+  console.log(`\n  ${T}Portfolio${R} — ${rows.length} project${rows.length === 1 ? "" : "s"}\n`);
+  for (const r of rows) {
+    const nm = r.name.slice(0, nameW).padEnd(nameW);
+    const st = r.stack.slice(0, stackW).padEnd(stackW);
+    const sc = r.score !== null ? `score ${String(r.score).padStart(3)}` : "         ";
+    const se = `${String(r.sessions).padStart(2)} session${r.sessions === 1 ? " " : "s"}`;
+    console.log(`  ${T}${nm}${R}  ${D}${st}${R}  ${sc}  ${se}  ${r.agents.padEnd(14)}  ${D}${r.ago}${R}`);
+  }
+
+  if (totalSessions > 0) {
+    const avg = scored > 0 ? Math.round(totalScore / scored) : 0;
+    const stacks = [...new Set(rows.map(r => r.stack))].length;
+    console.log(`\n  ${D}${"─".repeat(70)}`);
+    console.log(`  Total: ${totalSessions} sessions  ${stacks} stack${stacks === 1 ? "" : "s"}  avg effectiveness: ${avg}${R}\n`);
+  } else {
+    console.log(`\n  ${D}Tip: run '0dai init' in your projects to start tracking sessions.${R}\n`);
+  }
+}
+
+module.exports = { cmdPortfolio };

package/lib/commands/reflect.js

@@ -0,0 +1,211 @@
+"use strict";
+const shared = require("../shared");
+const { T, R, D, fs, path } = shared;
+
+function cmdReflect(target, args) {
+  const ai = path.join(target, "ai");
+  const W = process.stdout.isTTY ? "\x1b[33m" : "";
+  const G = process.stdout.isTTY ? "\x1b[32m" : "";
+  const R2 = process.stdout.isTTY ? "\x1b[0m" : "";
+  const B = process.stdout.isTTY ? "\x1b[1m" : "";
+
+  // Collect swarm done tasks
+  const doneDir = path.join(ai, "swarm", "done");
+  const queueDir = path.join(ai, "swarm", "queue");
+  const activeDir = path.join(ai, "swarm", "active");
+  const doneTasks = [], queueTasks = [];
+
+  // -- how many days to look back (default 7)
+  const daysArg = args.find((_, i) => args[i - 1] === "--days");
+  const days = parseInt(daysArg || "7");
+  const since = Date.now() - days * 24 * 60 * 60 * 1000;
+
+  const readJsonDir = (dir) => {
+    const out = [];
+    try {
+      for (const f of fs.readdirSync(dir).filter(f => f.endsWith(".json"))) {
+        try { out.push(JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"))); } catch {}
+      }
+    } catch {}
+    return out;
+  };
+
+  const allDone = readJsonDir(doneDir).filter(t => {
+    const ts = t.completed_at || t.created_at;
+    return !ts || new Date(ts).getTime() >= since;
+  });
+  const allQueue = readJsonDir(queueDir);
+  const allActive = readJsonDir(activeDir);
+
+  // Aggregate by agent
+  const byAgent = {};
+  for (const t of allDone) {
+    const a = t.assigned_to || t.agent || "unknown";
+    if (!byAgent[a]) byAgent[a] = { done: 0, tasks: [] };
+    byAgent[a].done++;
+    byAgent[a].tasks.push(t.title || t.id || "?");
+  }
+
+  // Session data
+  let sessionGoal = "?";
+  try {
+    const active = JSON.parse(fs.readFileSync(path.join(ai, "sessions", "active.json"), "utf8"));
+    sessionGoal = (active.task || {}).goal || "?";
+  } catch {}
+
+  console.log(`\n  ${B}${T}0dai reflect${R2}${R} — last ${days} days\n`);
+
+  // Goal
+  if (sessionGoal !== "?") console.log(`  ${B}Goal${R2}      ${sessionGoal}`);
+
+  // Delegation stats
+  const totalDone = allDone.length;
+  const totalPending = allQueue.length + allActive.length;
+  const successRate = totalDone + totalPending > 0
+    ? Math.round((totalDone / (totalDone + totalPending)) * 100)
+    : null;
+
+  console.log(`  ${B}Delivered${R2}  ${G}${totalDone}${R2} tasks completed`);
+  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 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));
+      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 {}
+
+  // Insights — learn from patterns
+  if (totalDone >= 3) {
+    const insights = [];
+    // Best agent by completion rate
+    const agentEntries = Object.entries(byAgent).map(([a, d]) => {
+      const pending = allPendingByAgent[a] || 0;
+      const total = d.done + pending;
+      return { agent: a, done: d.done, total, rate: total > 0 ? d.done / total : 1 };
+    });
+    const best = agentEntries.sort((a, b) => b.rate - a.rate)[0];
+    if (best && agentEntries.length > 1) {
+      insights.push(`${best.agent} has the highest success rate (${Math.round(best.rate * 100)}%)`);
+    }
+    // Fastest agent by avg elapsed
+    try {
+      const budget = JSON.parse(fs.readFileSync(path.join(ai, "swarm", "budget.json"), "utf8"));
+      const agentElapsed = {};
+      const agentCounts = {};
+      for (const t of Object.values(budget.tasks || {})) {
+        if (t.elapsed > 0) {
+          agentElapsed[t.agent] = (agentElapsed[t.agent] || 0) + t.elapsed;
+          agentCounts[t.agent] = (agentCounts[t.agent] || 0) + 1;
+        }
+      }
+      let fastest = null, fastestAvg = Infinity;
+      for (const [a, total] of Object.entries(agentElapsed)) {
+        const avg = total / agentCounts[a];
+        if (avg < fastestAvg) { fastest = a; fastestAvg = avg; }
+      }
+      if (fastest && Object.keys(agentElapsed).length > 1) {
+        insights.push(`${fastest} is fastest (avg ${Math.round(fastestAvg)}s per task)`);
+      }
+    } catch {}
+    // Cost efficiency
+    if (allDone.length > 0) {
+      try {
+        const budget = JSON.parse(fs.readFileSync(path.join(ai, "swarm", "budget.json"), "utf8"));
+        if (budget.total_spent > 0) {
+          const costPerTask = budget.total_spent / allDone.length;
+          insights.push(`avg cost: $${costPerTask.toFixed(4)}/task`);
+        }
+      } catch {}
+    }
+    if (insights.length) {
+      console.log(`\n  ${B}Insights:${R2}`);
+      for (const i of insights) console.log(`    ${G}→${R2} ${i}`);
+    }
+  }
+
+  // Remaining blockers
+  if (allQueue.length) {
+    console.log(`\n  ${B}Blockers / queue:${R2}`);
+    for (const t of allQueue.slice(0, 8)) {
+      const agent = t.assigned_to ? ` → ${t.assigned_to}` : "";
+      console.log(`    ${W}•${R2} ${(t.title || t.id || "?").slice(0, 60)}${agent}`);
+    }
+    if (allQueue.length > 8) console.log(`    ${D}… and ${allQueue.length - 8} more${R2}`);
+  }
+
+  // No data
+  if (!totalDone && !totalPending) {
+    console.log(`  ${D}No swarm tasks found in the last ${days} days.${R2}`);
+    console.log(`  ${D}Use '0dai swarm add --task "..." --to codex' to delegate tasks.${R2}`);
+  }
+
+  console.log();
+}
+
+module.exports = { cmdReflect };

package/lib/commands/report.js

@@ -0,0 +1,29 @@
+"use strict";
+const shared = require("../shared");
+const { log, D, R, spawnSync, findRepoScript, VERSION } = shared;
+
+function cmdReport(target, sub, args) {
+  const reportScript = findRepoScript(target, "report_manager.py");
+  if (!reportScript) {
+    log("report manager unavailable in this environment");
+    console.log(`  ${D}Expected scripts/report_manager.py in repo checkout${R}`);
+    process.exit(1);
+  }
+
+  const command = sub || "preview";
+  const forwarded = [reportScript, command, "--target", target, "--channel", "npm", "--cli-version", VERSION];
+
+  if (args.includes("--json")) forwarded.push("--json");
+  if (command === "auto") {
+    if (args.includes("--enable")) forwarded.push("--enable");
+    if (args.includes("--disable")) forwarded.push("--disable");
+    const idx = args.indexOf("--interval");
+    if (idx >= 0 && args[idx + 1]) forwarded.push("--interval", args[idx + 1]);
+  }
+
+  const result = spawnSync("python3", forwarded, { stdio: "inherit" });
+  if (typeof result.status === "number") process.exit(result.status);
+  process.exit(1);
+}
+
+module.exports = { cmdReport };

package/lib/commands/run.js

@@ -0,0 +1,77 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, apiCall } = shared;
+
+async function cmdRun(goal, target, args = []) {
+  if (!goal) {
+    console.log(`Usage: 0dai run <goal> [--dry-run] [--agent claude|codex|gemini]`);
+    console.log(`  Example: 0dai run "add dark mode to settings page"`);
+    return;
+  }
+
+  const dryRun = args.includes("--dry-run");
+  const agentIdx = args.indexOf("--agent");
+  const agentOverride = agentIdx >= 0 ? args[agentIdx + 1] : null;
+
+  // Read project context
+  let stack = "generic", agents = ["claude"], commands = {};
+  try {
+    const disc = JSON.parse(fs.readFileSync(path.join(target, "ai", "manifest", "discovery.json"), "utf8"));
+    stack = disc.stack || "generic";
+    agents = disc.selected_agents || ["claude"];
+  } catch {}
+
+  if (!dryRun) process.stdout.write(`${T}[0dai]${R} decomposing goal...`);
+  const result = await apiCall("/v1/run", { goal, context: { stack, agents, commands } });
+  if (!dryRun) process.stdout.write("\r" + " ".repeat(40) + "\r");
+
+  if (result.error) { log(`error: ${result.error}`); return; }
+
+  const tasks = result.tasks || [];
+  if (!tasks.length) { log("no tasks returned"); return; }
+
+  console.log(`\n  ${T}Goal:${R} ${goal}`);
+  console.log(`  Decomposed into ${tasks.length} task${tasks.length === 1 ? "" : "s"}:\n`);
+
+  for (let i = 0; i < tasks.length; i++) {
+    const t = tasks[i];
+    const agent = agentOverride || t.assigned_to;
+    console.log(`  ${T}${i + 1}.${R} ${t.title}`);
+    console.log(`     ${D}→ ${agent}  [${t.model_tier}]${t.description ? "  " + t.description : ""}${R}`);
+  }
+
+  if (dryRun) {
+    console.log(`\n  ${D}[dry-run] would create ${tasks.length} task(s) in swarm queue${R}\n`);
+    return;
+  }
+
+  // Create queue entries
+  const queueDir = path.join(target, "ai", "swarm", "queue");
+  try { fs.mkdirSync(queueDir, { recursive: true }); } catch {}
+
+  const created = [];
+  for (const t of tasks) {
+    const ts = Date.now();
+    const rand = Math.random().toString(36).slice(2, 6);
+    const id = `run-${ts}-${rand}`;
+    const entry = {
+      id,
+      title: t.title,
+      description: t.description || "",
+      assigned_to: agentOverride || t.assigned_to,
+      model_tier: t.model_tier,
+      created_by: "run",
+      created_at: new Date().toISOString(),
+      context: { goal },
+    };
+    try {
+      fs.writeFileSync(path.join(queueDir, `${id}.json`), JSON.stringify(entry, null, 2));
+      created.push(id);
+    } catch (e) { log(`warn: could not write task ${id}: ${e.message}`); }
+  }
+
+  console.log(`\n  ${T}✓${R} ${created.length} task${created.length === 1 ? "" : "s"} added to swarm queue`);
+  console.log(`  ${D}Monitor: 0dai watch  |  Queue: 0dai swarm status${R}\n`);
+}
+
+module.exports = { cmdRun };