@0dai-dev/cli 3.10.1 → 4.0.0

package/lib/commands/models.js

@@ -0,0 +1,57 @@
+"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`);
+}
+
+module.exports = { cmdModels };

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 };

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 };