@0dai-dev/cli 2.8.0 → 3.1.1

package/bin/0dai.js

@@ -7,7 +7,7 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const VERSION = "2.8.0";
+const VERSION = "3.0.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
@@ -16,6 +16,7 @@ const log = (msg) => console.log(`${T}[0dai]${R} ${msg}`);
 const CONFIG_DIR = path.join(os.homedir(), ".0dai");
 const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
 const VERSION_CHECK_FILE = path.join(CONFIG_DIR, ".version_check");
+const PROJECTS_FILE = path.join(CONFIG_DIR, "projects.json");
 
 const MANIFEST_FILES = [
   "package.json", "go.mod", "pyproject.toml", "requirements.txt",
@@ -53,6 +54,183 @@ function deviceFingerprint() {
   return crypto.createHash("sha256").update(parts.join(":")).digest("hex").slice(0, 32);
 }
 
+function registerProject(projectPath, name, stack) {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    let projects = [];
+    try { projects = JSON.parse(fs.readFileSync(PROJECTS_FILE, "utf8")).projects || []; } catch {}
+    const abs = path.resolve(projectPath);
+    const idx = projects.findIndex(p => p.path === abs);
+    const entry = { path: abs, name: name || path.basename(abs), stack: stack || "?", last_seen: new Date().toISOString() };
+    if (idx >= 0) projects[idx] = entry;
+    else projects.unshift(entry);
+    fs.writeFileSync(PROJECTS_FILE, JSON.stringify({ projects: projects.slice(0, 50) }, null, 2));
+  } catch {}
+}
+
+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`);
+  }
+}
+
+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`);
+}
+
 function apiCall(endpoint, data) {
   return new Promise((resolve, reject) => {
     const url = new URL(endpoint, API_URL);
@@ -126,27 +304,67 @@ function collectMetadata(target) {
   return { projectFiles, fileContents, clis };
 }
 
+// Fields in settings.json that belong to the user, not to 0dai
+const SETTINGS_PRESERVE_FIELDS = ["model", "permissionMode", "effortLevel"];
+
+function mergeSettingsJson(existing, incoming) {
+  try {
+    const base = JSON.parse(incoming);
+    const user = JSON.parse(existing);
+    // Preserve user-owned fields
+    for (const field of SETTINGS_PRESERVE_FIELDS) {
+      if (field in user && user[field] !== base[field]) {
+        base[field] = user[field];
+      }
+    }
+    return JSON.stringify(base, null, 2) + "\n";
+  } catch { return incoming; }
+}
+
+function mergeAgentsMd(existing, incoming) {
+  // If user marked as unmanaged, don't touch
+  if (existing.includes("managed: false")) return existing;
+  // If managed, update with new content but preserve user additions after managed block
+  return incoming;
+}
+
 function writeFiles(target, files) {
-  let created = 0, updated = 0, unchanged = 0;
+  let created = 0, updated = 0, unchanged = 0, merged = 0;
   for (const [rel, content] of Object.entries(files)) {
     const p = path.join(target, rel);
     fs.mkdirSync(path.dirname(p), { recursive: true });
-    try {
-      if (fs.existsSync(p) && fs.readFileSync(p, "utf8") === content) {
-        unchanged++;
+
+    let finalContent = content;
+
+    // Smart merge for specific files
+    if (fs.existsSync(p)) {
+      const existing = fs.readFileSync(p, "utf8");
+      if (existing === content) { unchanged++; continue; }
+
+      if (rel.endsWith("settings.json")) {
+        finalContent = mergeSettingsJson(existing, content);
+        merged++;
+      } else if (rel === "AGENTS.md" && existing.includes("managed: false")) {
+        unchanged++; // User owns this file, skip
         continue;
+      } else {
+        updated++;
       }
-      if (fs.existsSync(p)) updated++;
-      else created++;
-    } catch { created++; }
-    fs.writeFileSync(p, content, "utf8");
+    } else {
+      created++;
+    }
+
+    fs.writeFileSync(p, finalContent, "utf8");
   }
-  log(`${created} created, ${updated} updated, ${unchanged} unchanged`);
+  const parts = [`${created} created`, `${updated} updated`, `${unchanged} unchanged`];
+  if (merged) parts.push(`${merged} merged`);
+  log(parts.join(", "));
   return created + updated;
 }
 
 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();
@@ -169,6 +387,7 @@ async function cmdInit(target, args = []) {
     file_contents: fileContents,
     available_clis: clis,
     dry_run: dryRun,
+    minimal: minimal,
   });
 
   if (result.error) {
@@ -199,23 +418,28 @@ async function cmdInit(target, args = []) {
     if (!text.includes(".0dai")) fs.appendFileSync(gi, "\n.0dai/\n");
   } catch {}
 
+  // Register in global portfolio
+  registerProject(target, path.basename(target), result.stack);
+
   log(`initialized (${result.file_count || "?"} files)`);
   console.log("  skills: /build /review /status /feedback /bugfix /delegate");
 
-  // Send anonymous usage ping (stack + file count, no project data)
+  // Next steps — guide user to first value
+  console.log(`\n  ${T}Next steps:${R}`);
+  console.log(`  ${D}1.${R} Check health:  ${D}0dai doctor${R}`);
+  console.log(`  ${D}2.${R} Try delegation: ${D}0dai run "write tests for auth"${R}`);
+  console.log(`  ${D}3.${R} Open dashboard: ${D}https://0dai.dev/dashboard${R}`);
+
+  // Send anonymous usage ping
   apiCall("/v1/feedback", { report: {
     stack_detected: result.stack || "?", _auto: true, _plan: result.plan || "trial",
     _cli_version: VERSION, _files_generated: result.file_count || 0,
   }}).catch(() => {});
-
-  // Encourage feedback
-  console.log(`\n  ${T}Tip:${R} Send feedback to earn +5 init/day for 7 days:`);
-  console.log(`  ${D}0dai feedback log --type positive --detail "what worked"${R}`);
-  console.log(`  ${D}0dai feedback push${R}`);
 }
 
 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";
@@ -257,7 +481,7 @@ async function cmdSync(target, args = []) {
   const result = await apiCall("/v1/sync", {
     ai_version: version, stack, agents: agents.length ? agents : clis,
     current_files: currentFiles, file_contents: fileContents,
-    dry_run: dryRun,
+    dry_run: dryRun, quiet,
   });
 
   if (result.error) { log(`error: ${result.error}`); process.exit(1); }
@@ -273,8 +497,20 @@ async function cmdSync(target, args = []) {
     }
     return;
   }
-  if (Object.keys(updated).length) writeFiles(target, updated);
-  else log("already up to date");
+  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`);
+    console.log(`  ${D}Run: 0dai doctor to verify project health${R}`);
+  } else {
+    log("already up to date");
+  }
+
+  // Update portfolio registry
+  registerProject(target, path.basename(target), stack);
 }
 
 async function cmdDetect(target) {
@@ -543,14 +779,36 @@ function cmdValidate(target) {
     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) {
-    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}`);
+    console.log(`\n${E}${missing.length} missing${R2} / ${present.length + missing.length} total`);
     process.exitCode = 1;
   } else {
-    log(`${G}validate ok${R2} — all required files present`);
+    log(`${G}validate ok${R2} — all ${present.length} required files present`);
   }
 }
 
@@ -693,6 +951,55 @@ function cmdReflect(target, args) {
     }
   } 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}`);
@@ -712,6 +1019,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 = "?";
@@ -1225,6 +1672,119 @@ async function cmdFeedback(target, sub, args) {
   console.log("Usage: 0dai feedback [push|log|list] [--type ...] [--detail '...']");
 }
 
+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); });
+}
+
 async function main() {
   const args = process.argv.slice(2);
   let target = process.cwd();
@@ -1238,6 +1798,8 @@ async function main() {
   checkVersion();
 
   switch (cmd) {
+    case "run": await cmdRun(args[1] || "", target, args.slice(2)); break;
+    case "watch": cmdWatch(target, args.slice(1)); break;
     case "audit": cmdAudit(target); break;
     case "init": await cmdInit(target, args); break;
     case "sync": await cmdSync(target, args); break;
@@ -1245,6 +1807,8 @@ async function main() {
     case "doctor": cmdDoctor(target); break;
     case "validate": cmdValidate(target); break;
     case "reflect": cmdReflect(target, args); break;
+    case "metrics": cmdMetrics(target); break;
+    case "portfolio": cmdPortfolio(); break;
     case "status": cmdStatus(target); break;
     case "auth":
       if (sub === "login") await cmdAuthLogin();
@@ -1284,13 +1848,17 @@ async function main() {
     case "help": case "--help": case "-h":
       console.log(`\n  ${T}0dai${R} v${VERSION} — One config for 5 AI agent CLIs\n`);
       console.log("Commands:");
+      console.log("  run <goal>     AI-decompose goal → swarm tasks (auto-routed) [--dry-run]");
+      console.log("  watch          Live task monitor: queue, active, recently done [--interval N]");
       console.log("  audit          Scan ai/ and agent configs for leaked secrets");
-      console.log("  init           Initialize ai/ layer (via API) [--dry-run]");
-      console.log("  sync           Update ai/ layer (via API) [--dry-run]");
+      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("  portfolio      All tracked projects: score, sessions, agents, last activity");
       console.log("  status         Show maturity, swarm, session");
       console.log("  session save   Save session for roaming");
       console.log("  swarm status       Task queue & delegation");

package/package.json

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