@0dai-dev/cli 3.10.1 → 4.1.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,270 @@
+"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;
+  }
+
+  if (sub === "history") {
+    const authFile = path.join(require("os").homedir(), ".0dai", "auth.json");
+    let auth = {};
+    try { auth = JSON.parse(fs.readFileSync(authFile, "utf8")); } catch {}
+    const plan = (auth.plan || "free").toLowerCase();
+    const limitIdx = args.indexOf("--limit");
+    const limit = limitIdx >= 0 && args[limitIdx + 1] ? parseInt(args[limitIdx + 1], 10) || 50 : 50;
+    const sinceIdx = args.indexOf("--since");
+    const since = sinceIdx >= 0 ? args[sinceIdx + 1] : null;
+    const nodeIdx = args.indexOf("--node");
+    const nodeId = nodeIdx >= 0 ? args[nodeIdx + 1] : null;
+
+    if (["pro", "team", "enterprise"].includes(plan) && auth.access_token) {
+      const identity = buildProjectIdentity(target, collectMetadata(target));
+      const params = new URLSearchParams({
+        project_id: identity.project_id,
+        limit: String(Math.max(1, limit)),
+      });
+      if (since) params.set("since", since);
+      if (nodeId) params.set("target_id", nodeId);
+      const result = await apiCall(`/v1/graph/history?${params.toString()}`);
+      if (result.error) {
+        log(`Error: ${result.error}`);
+        if (result.hint) log(result.hint);
+        return;
+      }
+      const entries = result.mutations || [];
+      if (!entries.length) { console.log("  No graph history yet."); return; }
+      for (const entry of entries) {
+        const actor = (entry.agent || "unknown").padEnd(7);
+        const context = entry.context ? ` | "${entry.context}"` : "";
+        console.log(`  ${entry.timestamp || "?"} | ${actor} | ${entry.action.padEnd(13)} | ${entry.target_id}${context}`);
+      }
+      return;
+    }
+    log(`${D}Graph history requires Pro plan. Upgrade: 0dai upgrade${R}`);
+    return;
+  }
+
+  if (sub === "context") {
+    if (!fs.existsSync(graphFile)) {
+      log("No local graph found. Run: 0dai graph init or create ai/manifest/project_graph.json");
+      return;
+    }
+    const slicerScript = shared.findRepoScript(target, "graph_slicer_cli.py");
+    if (!slicerScript) {
+      log("graph slicer unavailable in this environment");
+      console.log(`  ${D}Expected scripts/graph_slicer_cli.py in repo checkout${R}`);
+      return;
+    }
+    const forwarded = [slicerScript, "--target", target];
+    let i = 0;
+    while (i < args.length) {
+      if (args[i] === "--scope" && args[i + 1]) { forwarded.push("--scope", args[i + 1]); i += 2; }
+      else if (args[i] === "--task" && args[i + 1]) { forwarded.push("--task", args[i + 1]); i += 2; }
+      else if (args[i] === "--depth" && args[i + 1]) { forwarded.push("--depth", args[i + 1]); i += 2; }
+      else if (args[i] === "--budget" && args[i + 1]) { forwarded.push("--budget", args[i + 1]); i += 2; }
+      else if (args[i] === "--json") { forwarded.push("--json"); i += 1; }
+      else { i += 1; }
+    }
+    const result = shared.spawnSync("python3", forwarded, { stdio: "inherit" });
+    if (typeof result.status === "number" && result.status !== 0) process.exit(result.status);
+    return;
+  }
+
+  if (sub === "outcomes") {
+    const authFile = path.join(require("os").homedir(), ".0dai", "auth.json");
+    let auth = {};
+    try { auth = JSON.parse(fs.readFileSync(authFile, "utf8")); } catch {}
+    const plan = (auth.plan || "free").toLowerCase();
+    if (!["pro", "team", "enterprise"].includes(plan)) {
+      log(`${D}Outcomes require Pro plan. Upgrade: 0dai upgrade${R}`);
+      return;
+    }
+    if (!auth.access_token) {
+      log("Graph outcomes requires an account. Run: 0dai auth login");
+      return;
+    }
+    const identity = buildProjectIdentity(target, collectMetadata(target));
+    const params = new URLSearchParams({ project_id: identity.project_id });
+    const limitIdx = args.indexOf("--limit");
+    if (limitIdx >= 0 && args[limitIdx + 1]) params.set("limit", args[limitIdx + 1]);
+    const sinceIdx = args.indexOf("--since");
+    if (sinceIdx >= 0 && args[sinceIdx + 1]) params.set("since", args[sinceIdx + 1]);
+    const result = await apiCall(`/v1/outcomes?${params.toString()}`);
+    if (result.error) { log(`Error: ${result.error}`); return; }
+    const stats = result.stats || {};
+    log(`Outcomes: ${stats.total || 0} total, ${stats.success_rate || 0}% success rate`);
+    if (result.outcomes && result.outcomes.length) {
+      for (const o of result.outcomes.slice(0, 10)) {
+        console.log(`  ${o.result || "?"} | ${o.agent || "?"} | ${o.title || o.task_id || "?"}`);
+      }
+    }
+    return;
+  }
+
+  console.log("Usage: 0dai graph [push|pull|status|history|context|outcomes]");
+  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");
+  console.log("  history  Show graph mutation timeline [--since 7d] [--node ID] [--limit 50]");
+  console.log("  context  Get relevant graph context for a task [--scope FILE] [--task TYPE]");
+  console.log("  outcomes Show outcome analytics (Pro only)");
+}
+
+module.exports = { cmdGraph };

package/lib/commands/init.js

@@ -0,0 +1,327 @@
+"use strict";
+const shared = require("../shared");
+const {
+  T, R, D, log,
+  fs, path,
+  VERSION, SUPPORTED_CLIS,
+  apiCall, makeEnsureAuthenticated, ensureLicenseActivation,
+  collectMetadata, buildProjectIdentity, registerProject,
+  writeFiles, writeManagedFiles, 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");
+  const force = args.includes("--force");
+  const updateTemplates = args.includes("--update-templates");
+
+  // Quick local check: skip API if already at current version (unless dry-run or force)
+  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}`);
+  if (force && !dryRun) log(`${T}force mode: will overwrite native configs from ai/ source${R}`);
+  if (updateTemplates && !dryRun) log(`${T}template update mode: will refresh managed native configs from latest templates${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, force, update_templates: updateTemplates,
+    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}`);
+    }
+    if (result.template_update_available) {
+      console.log(`  ${D}template update available: run 0dai sync --update-templates${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 (result.template_update_available && !updateTemplates && !quiet) {
+    console.log(`  ${D}Template update available: run 0dai sync --update-templates to refresh managed native configs${R}`);
+  }
+
+  // --force: also overwrite native configs (CLAUDE.md, AGENTS.md, etc.) from ai/ source
+  if (force && result.native_configs) {
+    let overwritten = 0;
+    for (const [name, content] of Object.entries(result.native_configs)) {
+      const targetPath = path.join(target, name);
+      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+      if (content) {
+        fs.writeFileSync(targetPath, content, "utf8");
+        overwritten++;
+        if (!quiet) console.log(`  [force] ${name} overwritten from ai/ source`);
+      }
+    }
+    if (overwritten && !quiet) {
+      log(`force: ${overwritten} native config file(s) overwritten`);
+    }
+  } else if (updateTemplates && result.native_configs) {
+    writeManagedFiles(target, result.native_configs);
+    if (!quiet) {
+      log("template update: managed native configs refreshed");
+    }
+  }
+
+  // --force: update drift baseline hashes so drift clears after regeneration
+  if (force) {
+    try {
+      const { spawnSync } = require("child_process");
+      const driftScript = path.join(target, "scripts", "drift_detector.py");
+      if (fs.existsSync(driftScript)) {
+        spawnSync("python3", [driftScript, "record", "--target", target], { stdio: "inherit" });
+      }
+    } catch {}
+  }
+
+  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 };