@0dai-dev/cli 3.10.1 → 4.0.0

package/lib/commands/feedback.js

@@ -0,0 +1,92 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, apiCall } = shared;
+
+async function cmdFeedbackPush(target) {
+  const fbDir = path.join(target, "ai", "feedback");
+  const items = [];
+
+  // Collect from report JSON files
+  try {
+    for (const f of fs.readdirSync(fbDir)) {
+      if (f.endsWith("-report.json") || (f.endsWith(".json") && f.match(/^\d{8}/))) {
+        try {
+          const d = JSON.parse(fs.readFileSync(path.join(fbDir, f), "utf8"));
+          if (d.project || d.verdict) items.push({ type: "report", data: d, file: f });
+        } catch {}
+      }
+    }
+  } catch {}
+
+  // Collect from operational.jsonl (feedback log entries)
+  const jsonlPath = path.join(fbDir, "operational.jsonl");
+  try {
+    if (fs.existsSync(jsonlPath)) {
+      const lines = fs.readFileSync(jsonlPath, "utf8").trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        try { items.push({ type: "log", data: JSON.parse(line) }); } catch {}
+      }
+    }
+  } catch {}
+
+  if (!items.length) {
+    log("no feedback found");
+    console.log(`  ${D}Log feedback first: 0dai feedback log --type suggestion --detail '...'${R}`);
+    return;
+  }
+
+  // Push all items
+  const report = {
+    project: path.basename(target),
+    entries: items.map(i => i.data),
+    count: items.length,
+    submitted_at: new Date().toISOString(),
+  };
+  log(`pushing ${items.length} feedback item(s)...`);
+  const result = await apiCall("/v1/feedback", { report });
+  if (result.received) {
+    log(`received${result.issue ? `: ${result.issue}` : ""}`);
+    if (result.bonus) log(`${T}bonus:${R} ${result.bonus}`);
+    // Archive pushed entries
+    if (fs.existsSync(jsonlPath)) {
+      const archivePath = path.join(fbDir, `pushed-${Date.now()}.jsonl`);
+      fs.renameSync(jsonlPath, archivePath);
+    }
+  } else {
+    log(`error: ${result.error || "unknown"}`);
+  }
+}
+
+async function cmdFeedback(target, sub, args) {
+  const fbDir = path.join(target, "ai", "feedback");
+
+  if (sub === "push") {
+    return cmdFeedbackPush(target);
+  }
+  if (sub === "log") {
+    const type = args.find((_, i) => args[i - 1] === "--type") || "suggestion";
+    const detail = args.find((_, i) => args[i - 1] === "--detail") || "";
+    if (!detail) { console.log("Usage: 0dai feedback log --type bug|suggestion|friction|positive --detail '...'"); return; }
+    fs.mkdirSync(fbDir, { recursive: true });
+    const entry = JSON.stringify({ ts: new Date().toISOString(), type, detail, agent: "cli" });
+    fs.appendFileSync(path.join(fbDir, "operational.jsonl"), entry + "\n");
+    log(`logged: [${type}] ${detail.slice(0, 60)}`);
+    return;
+  }
+  if (sub === "list") {
+    try {
+      const files = fs.readdirSync(fbDir).filter(f => f.endsWith("-report.json"));
+      if (!files.length) { log("no reports"); return; }
+      for (const f of files) {
+        try {
+          const d = JSON.parse(fs.readFileSync(path.join(fbDir, f), "utf8"));
+          console.log(`  ${f}: ${d.verdict || "?"} (${d.project || "?"})`);
+        } catch {}
+      }
+    } catch { log("no feedback directory"); }
+    return;
+  }
+  console.log("Usage: 0dai feedback [push|log|list] [--type ...] [--detail '...']");
+}
+
+module.exports = { cmdFeedbackPush, cmdFeedback };

package/lib/commands/graph.js

@@ -0,0 +1,171 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, apiCall, AUTH_FILE, buildProjectIdentity, collectMetadata, recordExperienceEvent } = shared;
+
+async function cmdGraph(target, sub, args) {
+  const graphFile = path.join(target, "ai", "manifest", "project_graph.json");
+
+  if (sub === "push") {
+    // Check auth
+    let auth;
+    try { auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8")); } catch {}
+    if (!auth || !auth.access_token) {
+      log("Graph push requires an account. Run: 0dai auth login");
+      return;
+    }
+
+    if (!fs.existsSync(graphFile)) {
+      log("No local graph found. Run: 0dai graph init or create ai/manifest/project_graph.json");
+      return;
+    }
+
+    let localGraph;
+    try { localGraph = JSON.parse(fs.readFileSync(graphFile, "utf8")); } catch (e) {
+      log(`Error reading graph file: ${e.message}`);
+      return;
+    }
+
+    const nodes = localGraph.nodes || {};
+    const edges = localGraph.edges || [];
+    const identity = buildProjectIdentity(target, collectMetadata(target));
+
+    log(`Pushing graph (${Object.keys(nodes).length} nodes, ${edges.length} edges)...`);
+    const result = await apiCall("/v1/graph/sync", {
+      project_id: identity.project_id,
+      nodes,
+      edges,
+    });
+
+    if (result.error) {
+      log(`Error: ${result.error}`);
+      return;
+    }
+
+    const parts = [];
+    if (result.added_nodes) parts.push(`${result.added_nodes} nodes added`);
+    if (result.updated_nodes) parts.push(`${result.updated_nodes} nodes updated`);
+    if (result.deleted_nodes) parts.push(`${result.deleted_nodes} nodes deleted`);
+    if (result.added_edges) parts.push(`${result.added_edges} edges added`);
+    if (result.deleted_edges) parts.push(`${result.deleted_edges} edges deleted`);
+
+    log(`Sync: ${parts.join(", ") || "up to date"}`);
+    if (result.edges_rejected) {
+      log(`${D}Edges rejected: upgrade to Pro for edge sync (0dai upgrade)${R}`);
+    }
+    recordExperienceEvent(target, {
+      event_type: "graph_synced",
+      agent: "cli",
+      model: "0dai-cli",
+      effort: "medium",
+      task: { goal: "push graph to server", task_type: "feat", result: "success", elapsed_seconds: 0, cost_usd: 0 },
+      context: { stack: "unknown", files_touched: 1, tests_passed: true, graph_nodes_used: Object.keys(nodes).length, graph_edges_used: edges.length },
+    });
+    return;
+  }
+
+  if (sub === "pull") {
+    let auth;
+    try { auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8")); } catch {}
+    if (!auth || !auth.access_token) {
+      log("Graph pull requires an account. Run: 0dai auth login");
+      return;
+    }
+
+    const identity = buildProjectIdentity(target, collectMetadata(target));
+    log("Pulling graph from server...");
+    const result = await apiCall(`/v1/graph/pull?project_id=${identity.project_id}`);
+
+    if (result.error) {
+      log(`Error: ${result.error}`);
+      if (result.hint) log(`Hint: ${result.hint}`);
+      return;
+    }
+
+    // Merge into local graph
+    let localGraph = { nodes: {}, edges: [], meta: {} };
+    if (fs.existsSync(graphFile)) {
+      try { localGraph = JSON.parse(fs.readFileSync(graphFile, "utf8")); } catch {}
+    }
+
+    // Merge nodes (server wins on conflicts)
+    const serverNodes = result.nodes || {};
+    const localNodes = localGraph.nodes || {};
+    const mergedNodes = { ...localNodes, ...serverNodes };
+
+    // Merge edges (server wins for Pro users)
+    const serverEdges = result.edges || [];
+    const localEdges = localGraph.edges || [];
+    const mergedEdges = [...localEdges, ...serverEdges];
+
+    // Deduplicate edges by (from, to, type)
+    const seen = new Set();
+    const uniqueEdges = [];
+    for (const e of mergedEdges) {
+      const key = `${e.from}|${e.to}|${e.type}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        uniqueEdges.push(e);
+      }
+    }
+
+    const merged = {
+      nodes: mergedNodes,
+      edges: uniqueEdges,
+      meta: {
+        ...localGraph.meta,
+        ...result.meta,
+        node_count: Object.keys(mergedNodes).length,
+        edge_count: uniqueEdges.length,
+      },
+    };
+
+    fs.mkdirSync(path.dirname(graphFile), { recursive: true });
+    fs.writeFileSync(graphFile, JSON.stringify(merged, null, 2) + "\n", "utf8");
+
+    log(`Pulled: ${Object.keys(mergedNodes).length} nodes, ${uniqueEdges.length} edges`);
+    if (result.meta && result.meta.edges_stripped) {
+      log(`${D}Edges not included: upgrade to Pro for full graph sync (0dai upgrade)${R}`);
+    }
+    recordExperienceEvent(target, {
+      event_type: "graph_synced",
+      agent: "cli",
+      model: "0dai-cli",
+      effort: "medium",
+      task: { goal: "pull graph from server", task_type: "feat", result: "success", elapsed_seconds: 0, cost_usd: 0 },
+      context: { stack: "unknown", files_touched: 1, tests_passed: true, graph_nodes_used: Object.keys(mergedNodes).length, graph_edges_used: uniqueEdges.length },
+    });
+    return;
+  }
+
+  if (sub === "status") {
+    let localNodes = 0, localEdges = 0;
+    if (fs.existsSync(graphFile)) {
+      try {
+        const g = JSON.parse(fs.readFileSync(graphFile, "utf8"));
+        localNodes = Object.keys(g.nodes || {}).length;
+        localEdges = (g.edges || []).length;
+      } catch {}
+    }
+
+    log(`Local graph: ${localNodes} nodes, ${localEdges} edges`);
+
+    // Check plan for edge sync status
+    let auth;
+    try { auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8")); } catch {}
+    if (auth && auth.access_token) {
+      const plan = (auth.plan || "free").toLowerCase();
+      const edgeStatus = plan === "free" ? `${D}nodes only (Pro for edges)${R}` : `${T}full sync${R}`;
+      log(`Server sync: ${edgeStatus}`);
+    } else {
+      log(`${D}Not authenticated — graph sync unavailable${R}`);
+    }
+    return;
+  }
+
+  console.log("Usage: 0dai graph [push|pull|status]");
+  console.log("  push   Upload local graph to server (Pro: edges, Free: nodes only)");
+  console.log("  pull   Download server graph and merge locally");
+  console.log("  status Show local graph stats and sync state");
+}
+
+module.exports = { cmdGraph };

package/lib/commands/init.js

@@ -0,0 +1,282 @@
+"use strict";
+const shared = require("../shared");
+const {
+  T, R, D, log,
+  fs, path,
+  VERSION, SUPPORTED_CLIS,
+  apiCall, makeEnsureAuthenticated, ensureLicenseActivation,
+  collectMetadata, buildProjectIdentity, registerProject,
+  writeFiles, sendProjectHeartbeat, recordExperienceEvent,
+} = shared;
+const { cmdAuthLogin } = require("./auth");
+
+const ensureAuthenticated = makeEnsureAuthenticated(cmdAuthLogin);
+
+// bindProjectForCloud — binds project to cloud via /v1/projects/bind
+async function bindProjectForCloud(target, metadata, identity) {
+  const result = await apiCall("/v1/projects/bind", {
+    ...identity,
+    stack: identity.stack || "unknown",
+  });
+  if (result.error) {
+    log(`error: ${result.error}`);
+    if (result.hint) console.log(`  ${result.hint}`);
+    process.exit(1);
+  }
+  return result.project || {
+    project_id: identity.project_id,
+    name: identity.project_name,
+    stack: identity.stack || "unknown",
+    binding_status: "bound",
+  };
+}
+
+async function cmdInit(target, args = []) {
+  const dryRun = args.includes("--dry-run");
+  const minimal = args.includes("--minimal");
+  const noWizard = args.includes("--no-wizard");
+
+  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.`);
+    return;
+  }
+
+  // First-run wizard (unless --no-wizard or non-interactive)
+  if (!noWizard && !dryRun && !minimal) {
+    try {
+      const { runWizard, isInteractive } = require("../wizard");
+      if (isInteractive()) {
+        const result = await runWizard(target);
+        if (result.completed) {
+          try {
+            const ob = require("../onboarding");
+            ob.trackFirstInit(target);
+            ob.showWhatsNext(result.mode || "local", false);
+          } catch {}
+          return;
+        }
+      }
+    } catch {}
+  }
+
+  const isTTY = process.stdout.isTTY;
+  let spinner = null;
+  if (isTTY) {
+    try { spinner = require("@clack/prompts").spinner(); } catch {}
+  }
+
+  const metadata = collectMetadata(target);
+  const { projectFiles, manifestContents, clis } = metadata;
+  const authStatus = await ensureAuthenticated("init");
+  const license = await ensureLicenseActivation();
+  const identity = buildProjectIdentity(target, metadata);
+  const boundProject = await bindProjectForCloud(target, metadata, identity);
+  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,
+    manifest_contents: manifestContents,
+    available_clis: clis,
+    dry_run: dryRun,
+    minimal: minimal,
+    project_name: identity.project_name,
+    project_id: boundProject.project_id || identity.project_id,
+    remote_origin: identity.remote_origin,
+    origin: identity.origin,
+    binding_source: "init",
+  });
+
+  if (result.error) {
+    if (result.hint) {
+      log(`${result.message || result.error}`);
+      console.log(`  ${result.hint}\n`);
+    } else {
+      log(`error: ${result.error}`);
+    }
+    process.exit(1);
+  }
+
+  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 || {});
+
+  // Ensure ai/VERSION matches CLI version
+  const versionFile = path.join(target, "ai", "VERSION");
+  fs.mkdirSync(path.dirname(versionFile), { recursive: true });
+  fs.writeFileSync(versionFile, VERSION + "\n", "utf8");
+
+  // Add to .gitignore
+  const gi = path.join(target, ".gitignore");
+  try {
+    const text = fs.existsSync(gi) ? fs.readFileSync(gi, "utf8") : "";
+    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(`  account: ${authStatus.email} · plan: ${authStatus.plan || license.plan || "free"} · activation: ${license.status}`);
+  console.log(`  project: ${boundProject.project_id || identity.project_id}`);
+  console.log("  skills: /build /review /status /feedback /bugfix /delegate");
+
+  // Detect agent auth status for smart onboarding hints
+  const { execFileSync: _ef } = require("child_process");
+  const agents = [];
+  try { _ef("claude", ["--version"], { timeout: 8000 }); agents.push("claude"); } catch {}
+  try { _ef("codex", ["--version"], { timeout: 8000 }); agents.push("codex"); } catch {}
+  try { _ef("gemini", ["--version"], { timeout: 8000 }); agents.push("gemini"); } catch {}
+
+  // 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}`);
+  if (agents.length > 0) {
+    const a = agents[0];
+    console.log(`  ${D}2.${R} Try delegation: ${D}0dai run "write tests for auth"${R}`);
+    console.log(`     ${D}(${agents.join(", ")} detected — delegation will use ${a} by default)${R}`);
+  } else {
+    console.log(`  ${D}2.${R} Install an agent CLI to enable delegation:`);
+    console.log(`     ${D}claude:${R} npm i -g @anthropic-ai/claude-code  ${D}(or Pro subscription)${R}`);
+    console.log(`     ${D}codex:${R}  npm i -g @openai/codex              ${D}(or ChatGPT Pro)${R}`);
+  }
+  console.log(`  ${D}3.${R} Open dashboard: ${D}https://0dai.dev/dashboard${R}`);
+
+  await sendProjectHeartbeat(identity, result, {
+    project_id: boundProject.project_id || identity.project_id,
+  }).catch(() => {});
+  recordExperienceEvent(target, {
+    event_type: "config_generated",
+    agent: "cli",
+    model: "0dai-cli",
+    effort: "medium",
+    task: { goal: "initialize ai layer", task_type: "feat", result: "success", elapsed_seconds: 0, cost_usd: 0 },
+    context: { stack: result.stack || identity.stack || "unknown", files_touched: Number(result.file_count || 0), tests_passed: true },
+  });
+
+  // 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(() => {});
+}
+
+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 {}
+
+  const metadata = collectMetadata(target);
+  const { manifestContents, clis } = metadata;
+  const authStatus = await ensureAuthenticated("sync");
+  const license = await ensureLicenseActivation();
+  let stack = "generic", agents = [];
+  try {
+    const d = JSON.parse(fs.readFileSync(path.join(target, "ai", "manifest", "discovery.json"), "utf8"));
+    stack = d.stack || "generic";
+    agents = d.selected_agents || [];
+  } catch {}
+  const identity = buildProjectIdentity(target, metadata, stack);
+  const boundProject = await bindProjectForCloud(target, metadata, identity);
+
+  // Collect current ai/ files
+  const currentFiles = {};
+  const aiDir = path.join(target, "ai");
+  if (fs.existsSync(aiDir)) {
+    const walk = (dir) => {
+      for (const f of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, f.name);
+        if (f.isDirectory()) walk(p);
+        else {
+          try {
+            const stat = fs.statSync(p);
+            if (stat.size < 10000) currentFiles[path.relative(target, p)] = fs.readFileSync(p, "utf8");
+          } catch {}
+        }
+      }
+    };
+    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, manifest_contents: manifestContents,
+    dry_run: dryRun, quiet,
+    project_name: identity.project_name,
+    project_id: boundProject.project_id || identity.project_id,
+    remote_origin: identity.remote_origin,
+    origin: identity.origin,
+    binding_source: "sync",
+  });
+
+  if (result.error) {
+    log(`error: ${result.error}`);
+    if (result.hint) console.log(`  ${result.hint}`);
+    process.exit(1);
+  }
+
+  const updated = result.files_updated || {};
+  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`);
+    console.log(`  ${D}Run: 0dai doctor to verify project health${R}`);
+  } else {
+    log("already up to date");
+  }
+  if (!quiet) {
+    console.log(`  account: ${authStatus.email} · plan: ${authStatus.plan || license.plan || "free"} · activation: ${license.status}`);
+    console.log(`  project: ${boundProject.project_id || identity.project_id}`);
+  }
+
+  // Ensure ai/VERSION matches CLI version after successful sync
+  const versionFile = path.join(target, "ai", "VERSION");
+  try {
+    const current = fs.existsSync(versionFile) ? fs.readFileSync(versionFile, "utf8").trim() : "";
+    if (current !== VERSION) {
+      fs.writeFileSync(versionFile, VERSION + "\n", "utf8");
+    }
+  } catch {}
+
+  // Update portfolio registry
+  registerProject(target, path.basename(target), stack);
+  await sendProjectHeartbeat(identity, result, {
+    project_id: boundProject.project_id || identity.project_id,
+  }).catch(() => {});
+  recordExperienceEvent(target, {
+    event_type: "config_generated",
+    agent: "cli",
+    model: "0dai-cli",
+    effort: "medium",
+    task: { goal: "sync ai layer", task_type: "feat", result: "success", elapsed_seconds: 0, cost_usd: 0 },
+    context: { stack: stack || identity.stack || "unknown", files_touched: changedCount, tests_passed: true },
+  });
+}
+
+module.exports = { cmdInit, cmdSync };

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