@0dai-dev/cli 4.0.0 → 4.1.0

package/bin/0dai.js

@@ -32,6 +32,7 @@ const { cmdFeedback, cmdFeedbackPush } = require("../lib/commands/feedback");
 const { cmdGraph } = require("../lib/commands/graph");
 const { cmdReport } = require("../lib/commands/report");
 const { cmdExperience } = require("../lib/commands/experience");
+const { cmdWorkspace } = require("../lib/commands/workspace");
 
 async function main() {
   const args = process.argv.slice(2);
@@ -67,6 +68,29 @@ async function main() {
     case "watch": cmdWatch(target, args.slice(1)); break;
     case "audit": cmdAudit(target); break;
     case "security": {
+      const subSec = args[1] || "";
+      if (subSec === "install-hook") {
+        const hooksDir = path.join(target, ".git", "hooks");
+        if (!fs.existsSync(hooksDir)) { log("not a git repo"); break; }
+        const hookPath = path.join(hooksDir, "pre-commit");
+        const hookSource = path.join(__dirname, "..", "..", "..", "scripts", "hooks", "pre-commit.sh");
+        if (fs.existsSync(hookSource)) {
+          fs.copyFileSync(hookSource, hookPath);
+          fs.chmodSync(hookPath, 0o755);
+          log("pre-commit hook installed: " + hookPath);
+        } else {
+          // Inline install: copy from repo scripts if available
+          const repoHook = findRepoScript(target, "hooks/pre-commit.sh");
+          if (repoHook) {
+            fs.copyFileSync(repoHook, hookPath);
+            fs.chmodSync(hookPath, 0o755);
+            log("pre-commit hook installed: " + hookPath);
+          } else {
+            log("hook source not found — run: 0dai security install-hook from repo root");
+          }
+        }
+        break;
+      }
       const secScript = findRepoScript(target, "scan_secrets.py");
       if (!secScript) { log("secret scanner unavailable"); break; }
       const fwd = [secScript, "--target", target];
@@ -117,11 +141,38 @@ async function main() {
       break;
     case "session": cmdSession(target, sub, args); break;
     case "swarm": cmdSwarm(target, sub, args); break;
+    case "workspace": cmdWorkspace(target, sub, args.slice(2)); break;
     case "feedback": await cmdFeedback(target, sub, args); break;
     case "report": cmdReport(target, sub, args); break;
     case "experience": cmdExperience(target, sub, args); break;
     case "graph": await cmdGraph(target, sub, args); break;
     case "models": cmdModels(sub || args[1]); break;
+    case "delegate": case "delegation": {
+      const deScript = findRepoScript(target, "delegation_engine.py");
+      if (!deScript) { log("delegation engine unavailable"); break; }
+      const deCmd = cmd === "delegate" ? "delegate" : (sub || "show");
+      const fwd = [deScript, deCmd, "--target", target];
+      if (deCmd === "delegate") {
+        // Find goal: first non-flag arg after delegate, or --goal value
+        let goal = "";
+        for (let i = 0; i < args.length; i++) {
+          if (args[i] === "--goal" && args[i + 1]) { goal = args[i + 1]; i++; }
+          else if (!args[i].startsWith("-") && !goal) goal = args[i];
+        }
+        if (sub && !sub.startsWith("-")) goal = goal || sub;
+        if (goal) fwd.push(goal);
+        for (let i = 0; i < args.length; i++) {
+          if (args[i] === "--agent" && args[i + 1]) { fwd.push("--agent", args[i + 1]); i++; }
+          else if (args[i] === "--model" && args[i + 1]) { fwd.push("--model", args[i + 1]); i++; }
+          else if (args[i] === "--task-type" && args[i + 1]) { fwd.push("--task-type", args[i + 1]); i++; }
+        }
+        if (args.includes("--dry-run")) fwd.push("--dry-run");
+      }
+      if (args.includes("--json")) fwd.push("--json");
+      const result = spawnSync("python3", fwd, { stdio: "inherit", timeout: 15000 });
+      if (typeof result.status === "number" && result.status !== 0) process.exit(result.status);
+      break;
+    }
     case "redeem": await cmdRedeem(sub || args[1]); break;
     case "terminal": case "term":
       try {
@@ -192,7 +243,7 @@ async function main() {
       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] [--minimal]");
-      console.log("  sync           Update ai/ layer (via API) [--dry-run] [--quiet]");
+      console.log("  sync           Update ai/ layer (via API) [--dry-run] [--quiet] [--force]");
       console.log("  detect         Show detected stack");
       console.log("  doctor         Check health + credentials checklist");
       console.log("  update         Update all installed agent CLIs to latest [--dry-run]");
@@ -206,6 +257,9 @@ async function main() {
       console.log("  swarm webhook add  Register webhook (fires on task done/failed)");
       console.log("  swarm webhook list Show registered webhooks");
       console.log("  swarm webhook test Send test ping to a webhook URL");
+      console.log("  workspace init     Create tmux workspace config (auto-detect services)");
+      console.log("  workspace up       Start all workspace sessions");
+      console.log("  workspace status   Show session status table");
       console.log("  feedback push  Send feedback to 0dai");
       console.log("  report preview Preview privacy-safe project report");
       console.log("  report push    Send report to 0dai (with offline queue)");
@@ -216,6 +270,8 @@ async function main() {
       console.log("  graph pull     Download server graph and merge locally");
       console.log("  graph status   Show local graph stats and sync state");
       console.log("  models         Show model ratings (--fast/--balanced/--deep/--available)");
+      console.log("  delegate       Auto-route task to best agent/model (0dai delegate 'goal')");
+      console.log("  delegation show  Show current delegation policy");
       console.log("  terminal       Launch interactive agent session");
       console.log("  auth login     Authenticate (device code flow)");
       console.log("  auth logout    Remove credentials");

package/lib/commands/graph.js

@@ -162,10 +162,109 @@ async function cmdGraph(target, sub, args) {
     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");
+  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

@@ -6,7 +6,7 @@ const {
   VERSION, SUPPORTED_CLIS,
   apiCall, makeEnsureAuthenticated, ensureLicenseActivation,
   collectMetadata, buildProjectIdentity, registerProject,
-  writeFiles, sendProjectHeartbeat, recordExperienceEvent,
+  writeFiles, writeManagedFiles, sendProjectHeartbeat, recordExperienceEvent,
 } = shared;
 const { cmdAuthLogin } = require("./auth");
 
@@ -172,8 +172,10 @@ async function cmdInit(target, args = []) {
 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)
+  // 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 {}
 
@@ -210,11 +212,13 @@ async function cmdSync(target, args = []) {
   }
 
   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,
+    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,
@@ -237,6 +241,9 @@ async function cmdSync(target, args = []) {
     } 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;
@@ -250,6 +257,44 @@ async function cmdSync(target, args = []) {
   } 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}`);

package/lib/commands/models.js

@@ -54,4 +54,37 @@ function cmdModels(filter) {
   console.log(`  ${DIM}Full table: https://0dai.dev/models${R}\n`);
 }
 
-module.exports = { cmdModels };
+async function cmdModelsRecommend(target, args) {
+  const shared = require("../shared");
+  const { log, T, R, D, findRepoScript, spawnSync, requirePlan } = shared;
+
+  const gate = requirePlan("pro", "Model Recommend", target);
+  if (gate) { log(gate.error); log(gate.hint); return; }
+
+  const taskType = args.find((_, i) => args[i - 1] === "--task") || "";
+  const goal = args.find((_, i) => args[i - 1] === "--goal") || "";
+  const maxCost = parseFloat(args.find((_, i) => args[i - 1] === "--max-cost") || "0");
+  const minQuality = parseFloat(args.find((_, i) => args[i - 1] === "--min-quality") || "0");
+  const asJson = args.includes("--json");
+
+  if (!taskType && !goal) {
+    console.log("Usage: 0dai models recommend --task TYPE [--goal '...'] [--max-cost N] [--min-quality N] [--json]");
+    console.log("  TYPE: feat, fix, refactor, test, docs");
+    return;
+  }
+
+  const recScript = findRepoScript(target, "model_router.py");
+  if (!recScript) { log("model router unavailable"); return; }
+
+  const fwd = [recScript, "recommend", "--target", target];
+  if (taskType) fwd.push("--task", taskType);
+  if (goal) fwd.push("--goal", goal);
+  if (maxCost > 0) fwd.push("--max-cost", String(maxCost));
+  if (minQuality > 0) fwd.push("--min-quality", String(minQuality));
+  if (asJson) fwd.push("--json");
+
+  const result = spawnSync("python3", fwd, { stdio: "inherit" });
+  if (typeof result.status === "number" && result.status !== 0) process.exit(result.status);
+}
+
+module.exports = { cmdModels, cmdModelsRecommend };

package/lib/commands/swarm.js

@@ -155,7 +155,45 @@ function cmdSwarm(target, sub, args) {
     console.log();
     return;
   }
-  console.log("Usage: 0dai swarm [status|add|delegate|budget] [--task '...'] [--to agent]");
+  if (sub === "estimate") {
+    const gate = requirePlan("pro", "Swarm Estimate", target);
+    if (gate) { log(gate.error); log(gate.hint); return; }
+    const goal = args.find((_, i) => args[i - 1] === "--goal") || "";
+    if (!goal) { console.log("Usage: 0dai swarm estimate --goal '...' [--agent claude|codex] [--model tier] [--json]"); return; }
+    const agent = args.find((_, i) => args[i - 1] === "--agent") || "";
+    const model = args.find((_, i) => args[i - 1] === "--model") || "";
+    const asJson = args.includes("--json");
+    // Call API for cost estimate
+    const identity = shared.buildProjectIdentity(target, shared.collectMetadata(target));
+    shared.apiCall("/v1/swarm/estimate", { goal, agent, model_tier: model, project_id: identity.project_id }).then((result) => {
+      if (result.error) { log(`error: ${result.error}`); return; }
+      if (asJson) { console.log(JSON.stringify(result, null, 2)); return; }
+      log(`Cost estimate for: ${goal}`);
+      console.log(`  ${D}Estimated: $${(result.estimated_cost_usd || 0).toFixed(4)} · ${result.estimated_tokens || "?"} tokens · ${result.estimated_time_s || "?"}s${R}`);
+      if (result.model_recommendation) console.log(`  ${T}Recommended: ${result.model_recommendation}${R}`);
+      if (result.tier_breakdown) {
+        for (const [tier, cost] of Object.entries(result.tier_breakdown)) {
+          console.log(`    ${tier}: $${cost.toFixed(4)}`);
+        }
+      }
+    });
+    return;
+  }
+  if (sub === "quality") {
+    const scorerScript = findRepoScript(target, "quality_scorer.py");
+    if (!scorerScript) { log("quality scorer unavailable"); return; }
+    const fwd = [scorerScript, "--target", target];
+    if (args.includes("--json")) fwd.push("--json");
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === "--last" && args[i + 1]) { fwd.push("--last", args[i + 1]); i++; }
+      else if (args[i] === "--details" && args[i + 1]) { fwd.push("--details", args[i + 1]); i++; }
+    }
+    const result = spawnSync("python3", fwd, { stdio: "inherit", timeout: 15000 });
+    if (typeof result.status === "number" && result.status !== 0) process.exit(result.status);
+    return;
+  }
+  console.log("Usage: 0dai swarm [status|add|delegate|budget|estimate|quality] [--task '...'] [--to agent]");
+  console.log("  quality   Show quality scores for recent tasks (--last N / --details TASK_ID)");
 }
 
 module.exports = { cmdSwarm };

package/lib/commands/workspace.js

@@ -0,0 +1,296 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, fs, path, spawnSync } = shared;
+const os = require("os");
+
+const CONFIG_NAME = "workspace.json";
+
+function findConfig(target) {
+  const local = path.join(target, ".0dai", CONFIG_NAME);
+  if (fs.existsSync(local)) return { file: local, scope: "local" };
+  const globalFile = path.join(os.homedir(), ".0dai", CONFIG_NAME);
+  if (fs.existsSync(globalFile)) return { file: globalFile, scope: "global" };
+  return null;
+}
+
+function loadConfig(target) {
+  const found = findConfig(target);
+  if (!found) return null;
+  try { return JSON.parse(fs.readFileSync(found.file, "utf8")); } catch { return null; }
+}
+
+function saveConfig(target, ws, globalFlag) {
+  const configFile = globalFlag
+    ? path.join(os.homedir(), ".0dai", CONFIG_NAME)
+    : path.join(target, ".0dai", CONFIG_NAME);
+  fs.mkdirSync(path.dirname(configFile), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(configFile, JSON.stringify(ws, null, 2) + "\n", { mode: 0o600 });
+  return configFile;
+}
+
+function tmux(args) {
+  try {
+    return spawnSync("tmux", args, { encoding: "utf8", timeout: 5000 });
+  } catch { return { status: 1, stderr: "tmux not found" }; }
+}
+
+function sessionName(name) {
+  return "0dai-" + name.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+}
+
+function listTmuxSessions() {
+  const r = tmux(["list-sessions", "-F", "#{session_name}\t#{session_created}\t#{pane_pid}"]);
+  if (r.status !== 0) return [];
+  return r.stdout.trim().split("\n").filter(Boolean).map(line => {
+    const [name, created, pid] = line.split("\t");
+    return { name, created, pid };
+  });
+}
+
+// --- Auto-detection ---
+
+function detectSessions(target) {
+  const sessions = [];
+
+  // API server
+  if (fs.existsSync(path.join(target, "scripts", "api_server.py"))) {
+    sessions.push({
+      name: "api",
+      cmd: "python3 api_server.py --public --port 8440",
+      dir: "scripts",
+      auto_start: true,
+    });
+  }
+
+  // Web dev (Next.js, etc.)
+  const pkgPath = path.join(target, "web", "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.scripts && pkg.scripts.dev) {
+        sessions.push({ name: "web", cmd: "npm run dev", dir: "web", auto_start: true });
+      }
+    } catch {}
+  }
+
+  // Uptime monitor
+  if (fs.existsSync(path.join(target, "scripts", "uptime_monitor.py"))) {
+    sessions.push({
+      name: "monitor",
+      cmd: "python3 uptime_monitor.py --url http://localhost:8440",
+      dir: "scripts",
+      auto_start: false,
+    });
+  }
+
+  // Procfile support
+  const procfile = path.join(target, "Procfile");
+  if (fs.existsSync(procfile)) {
+    try {
+      const lines = fs.readFileSync(procfile, "utf8").split("\n");
+      for (const line of lines) {
+        const m = line.match(/^(\w+):\s*(.+)$/);
+        if (m) {
+          const existing = sessions.find(s => s.name === m[1]);
+          if (!existing) {
+            sessions.push({ name: m[1], cmd: m[2], dir: ".", auto_start: true });
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return sessions;
+}
+
+// --- Commands ---
+
+function cmdWorkspaceInit(target, args) {
+  const globalFlag = args.includes("--global");
+
+  if (sessions.length === 0) {
+    log("no services detected. Create workspace config manually with: 0dai workspace add");
+    return;
+  }
+
+  const ws = {
+    name: path.basename(target),
+    root: target,
+    sessions,
+  };
+
+  const configFile = saveConfig(target, ws, globalFlag);
+  log(`workspace config created: ${T}${configFile}${R}`);
+  log(`${sessions.length} session(s) detected: ${sessions.map(s => s.name).join(", ")}`);
+  log(`run: ${T}0dai workspace up${R}`);
+}
+
+function cmdWorkspaceAdd(target, args) {
+  const nameIdx = args.indexOf("add");
+  const name = nameIdx >= 0 ? args[nameIdx + 1] : args[0];
+  if (!name) { log("usage: 0dai workspace add <name> --cmd '...' [--dir scripts] [--auto]"); return; }
+
+  const ws = loadConfig(target) || { name: path.basename(target), sessions: [] };
+  const cmdIdx = args.indexOf("--cmd");
+  const dirIdx = args.indexOf("--dir");
+  const cmd = cmdIdx >= 0 && args[cmdIdx + 1] ? args[cmdIdx + 1] : name;
+  const dir = dirIdx >= 0 && args[dirIdx + 1] ? args[dirIdx + 1] : ".";
+  const auto = args.includes("--auto");
+
+  const existing = ws.sessions.findIndex(s => s.name === name);
+  const entry = { name, cmd, dir, auto_start: auto };
+  if (existing >= 0) ws.sessions[existing] = entry;
+  else ws.sessions.push(entry);
+
+  const found = findConfig(target);
+  const configFile = found ? found.file : saveConfig(target, ws, false);
+  fs.writeFileSync(configFile, JSON.stringify(ws, null, 2) + "\n", { mode: 0o600 });
+  log(`session "${T}${name}${R}" ${existing >= 0 ? "updated" : "added"}`);
+}
+
+function cmdWorkspaceRm(target, name) {
+  if (!name) { log("usage: 0dai workspace rm <name>"); return; }
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config"); return; }
+  ws.sessions = ws.sessions.filter(s => s.name !== name);
+  const found = findConfig(target);
+  fs.writeFileSync(found.file, JSON.stringify(ws, null, 2) + "\n", { mode: 0o600 });
+  log(`session "${T}${name}${R}" removed`);
+}
+
+function cmdWorkspaceUp(target, args) {
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config. Run: 0dai workspace init"); return; }
+
+  // Filter by name if specified
+  const filterNames = args.filter(a => !a.startsWith("-"));
+  const running = listTmuxSessions();
+
+  log(`starting workspace "${T}${ws.name}${R}"`);
+
+  for (const s of ws.sessions) {
+    if (!s.auto_start) continue;
+    if (filterNames.length && !filterNames.includes(s.name)) continue;
+
+    const sname = sessionName(s.name);
+    if (running.find(x => x.name === sname)) {
+      log(`${D}${s.name} already running (pid ${running.find(x => x.name === sname).pid})${R}`);
+      continue;
+    }
+
+    const dir = s.dir ? path.join(ws.root || target, s.dir) : (ws.root || target);
+    const cmd = `cd ${dir} && ${s.cmd}`;
+    const r = tmux(["new-session", "-d", "-s", sname, "bash", "-lc", cmd]);
+    if (r.status === 0) log(`${T}✓${R} ${s.name} started`);
+    else log(`${R}✗${R} ${s.name} failed: ${r.stderr?.trim() || r.error || "unknown"}`);
+  }
+
+  if (filterNames.length === 0) {
+    log(`workspace ready. ${D}Status: 0dai workspace status${R}`);
+  }
+}
+
+function cmdWorkspaceDown(target, args) {
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config"); return; }
+
+  const filterNames = args.filter(a => !a.startsWith("-"));
+  log(`stopping workspace "${T}${ws.name}${R}"`);
+
+  for (const s of ws.sessions) {
+    if (filterNames.length && !filterNames.includes(s.name)) continue;
+    const sname = sessionName(s.name);
+    tmux(["kill-session", "-t", sname]);
+    log(`${D}${s.name} stopped${R}`);
+  }
+}
+
+function cmdWorkspaceStatus(target) {
+  const ws = loadConfig(target);
+  if (!ws) { log("no workspace config. Run: 0dai workspace init"); return; }
+
+  const running = listTmuxSessions();
+  const isTTY = process.stdout.isTTY;
+  const G = isTTY ? "\x1b[32m" : "";
+  const RD = isTTY ? "\x1b[31m" : "";
+  const DIM = isTTY ? "\x1b[2m" : "";
+
+  console.log(`\n  ${T}Workspace: ${ws.name}${R}\n`);
+  console.log(`  ${"SESSION".padEnd(14)} ${"STATUS".padEnd(10)} ${"PID".padEnd(8)} DIR`);
+  console.log(`  ${"-".repeat(60)}`);
+
+  for (const s of ws.sessions) {
+    const sname = sessionName(s.name);
+    const match = running.find(x => x.name === sname);
+    const status = match ? `${G}running${R}` : `${RD}stopped${R}`;
+    const pid = match ? match.pid : "—";
+    const dir = s.dir || ".";
+    console.log(`  ${s.name.padEnd(14)} ${status.padEnd(10)} ${String(pid).padEnd(8)} ${DIM}${dir}${R}`);
+  }
+  console.log();
+}
+
+function cmdWorkspaceAttach(target, name) {
+  if (!name) { log("usage: 0dai workspace attach <name>"); return; }
+  const sname = sessionName(name);
+  const running = listTmuxSessions();
+  if (!running.find(x => x.name === sname)) {
+    log(`session "${name}" not running. Run: 0dai workspace up`);
+    return;
+  }
+  log(`attaching to ${T}${name}${R}`);
+  try {
+    const { execSync } = require("child_process");
+    execSync(`tmux attach -t ${sname}`, { stdio: "inherit" });
+  } catch (e) { log(`error: ${e.message}`); }
+}
+
+function cmdWorkspaceLogs(target, name, args) {
+  if (!name) { log("usage: 0dai workspace logs <name> [-f]"); return; }
+  const sname = sessionName(name);
+  const running = listTmuxSessions();
+  if (!running.find(x => x.name === sname)) { log(`session "${name}" not running`); return; }
+
+  const follow = args.includes("-f") || args.includes("--follow");
+  if (follow) {
+    // Live follow mode
+    log(`following ${T}${name}${R} logs (Ctrl+C to exit)`);
+    try {
+      const { execSync } = require("child_process");
+      execSync(`tmux capture-pane -t ${sname} -p -e`, { stdio: "inherit" });
+    } catch (e) { log(`error: ${e.message}`); }
+  } else {
+    const r = tmux(["capture-pane", "-t", sname, "-p"]);
+    if (r.stdout) {
+      const lines = r.stdout.trim().split("\n").slice(-50);
+      console.log(lines.join("\n"));
+    }
+  }
+}
+
+function cmdWorkspace(target, sub, args) {
+  switch (sub) {
+    case "init": cmdWorkspaceInit(target, args); break;
+    case "up": cmdWorkspaceUp(target, args); break;
+    case "down": cmdWorkspaceDown(target, args); break;
+    case "status": cmdWorkspaceStatus(target); break;
+    case "attach": cmdWorkspaceAttach(target, args[0]); break;
+    case "logs": cmdWorkspaceLogs(target, args[0], args); break;
+    case "add": cmdWorkspaceAdd(target, args); break;
+    case "rm": cmdWorkspaceRm(target, args[0]); break;
+    default:
+      console.log(`\n  ${T}0dai workspace${R} — tmux session manager\n`);
+      console.log("Commands:");
+      console.log("  workspace init [--global]   Create config (auto-detect services)");
+      console.log("  workspace up [name...]       Start auto_start sessions (filter by name)");
+      console.log("  workspace down [name...]     Stop sessions (filter by name)");
+      console.log("  workspace status             Show session status table");
+      console.log("  workspace attach <name>      Attach to a running session");
+      console.log("  workspace logs <name> [-f]   Show session output (-f = follow)");
+      console.log("  workspace add <name> --cmd '...' [--dir X] [--auto]");
+      console.log("  workspace rm <name>          Remove session from config");
+      console.log();
+  }
+}
+
+module.exports = { cmdWorkspace };

package/lib/shared.js

@@ -48,6 +48,10 @@ 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 MANAGED_BEGIN = "<!-- 0dai:managed:begin -->";
+const MANAGED_END = "<!-- 0dai:managed:end -->";
+const LEGACY_MANAGED_BEGIN = "<!-- zerodayai:managed:begin -->";
+const LEGACY_MANAGED_END = "<!-- zerodayai:managed:end -->";
 
 // --- API ---
 function apiCall(endpoint, data) {
@@ -180,6 +184,31 @@ function mergeSettingsJson(existing, incoming) {
   } catch { return incoming; }
 }
 
+function mergeManagedMarkdown(existing, incoming) {
+  let src = incoming;
+  if (src.startsWith("# managed: true")) {
+    src = src.split("\n").slice(1).join("\n").trimStart();
+  }
+  const managedBody = `${MANAGED_BEGIN}\n${src.trim()}\n${MANAGED_END}\n`;
+  if (existing.includes(MANAGED_BEGIN) && existing.includes(MANAGED_END)) {
+    const start = existing.indexOf(MANAGED_BEGIN);
+    const finish = existing.indexOf(MANAGED_END) + MANAGED_END.length;
+    return existing.slice(0, start) + managedBody + existing.slice(finish);
+  }
+  if (existing.includes(LEGACY_MANAGED_BEGIN) && existing.includes(LEGACY_MANAGED_END)) {
+    const finish = existing.indexOf(LEGACY_MANAGED_END) + LEGACY_MANAGED_END.length;
+    const rest = existing.slice(finish).trimStart();
+    return rest ? `${managedBody}\n${rest}` : managedBody;
+  }
+  return `${managedBody}\n${existing}`;
+}
+
+function contentLooksManaged(existing) {
+  return existing.includes("managed: true") || existing.includes('"managed": true') ||
+    (existing.includes(MANAGED_BEGIN) && existing.includes(MANAGED_END)) ||
+    (existing.includes(LEGACY_MANAGED_BEGIN) && existing.includes(LEGACY_MANAGED_END));
+}
+
 function writeFiles(target, files) {
   let created = 0, updated = 0, unchanged = 0, merged = 0, skipped = 0;
   const targetResolved = path.resolve(target);
@@ -212,6 +241,54 @@ function writeFiles(target, files) {
   return created + updated;
 }
 
+function writeManagedFiles(target, files) {
+  let created = 0, updated = 0, unchanged = 0, merged = 0, staged = 0, skipped = 0;
+  const targetResolved = path.resolve(target);
+  for (const [rel, content] of Object.entries(files)) {
+    if (typeof rel !== "string" || !rel || path.isAbsolute(rel) || rel.split(/[/\\]/).includes("..")) {
+      skipped++; continue;
+    }
+    const p = path.resolve(targetResolved, rel);
+    if (!p.startsWith(targetResolved + path.sep) && p !== targetResolved) { skipped++; continue; }
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    if (!fs.existsSync(p)) {
+      fs.writeFileSync(p, content, "utf8");
+      created++;
+      continue;
+    }
+    const existing = fs.readFileSync(p, "utf8");
+    if (existing === content) {
+      unchanged++;
+      continue;
+    }
+
+    if (rel.endsWith("settings.json")) {
+      fs.writeFileSync(p, mergeSettingsJson(existing, content), "utf8");
+      merged++;
+      continue;
+    }
+    if (rel === "AGENTS.md" || rel.endsWith("/CLAUDE.md")) {
+      fs.writeFileSync(p, mergeManagedMarkdown(existing, content), "utf8");
+      merged++;
+      continue;
+    }
+    if (!contentLooksManaged(existing)) {
+      fs.writeFileSync(`${p}.generated`, content, "utf8");
+      staged++;
+      continue;
+    }
+
+    fs.writeFileSync(p, content, "utf8");
+    updated++;
+  }
+  const parts = [`${created} created`, `${updated} updated`, `${unchanged} unchanged`];
+  if (merged) parts.push(`${merged} merged`);
+  if (staged) parts.push(`${staged} staged`);
+  if (skipped) parts.push(`${skipped} skipped (unsafe path)`);
+  log(parts.join(", "));
+  return created + updated + merged;
+}
+
 // --- Repo Script Lookup ---
 function findRepoScript(target, scriptName) {
   const candidates = [
@@ -275,7 +352,7 @@ module.exports = {
   // Project
   sendProjectHeartbeat, recordExperienceEvent,
   // Files
-  mergeSettingsJson, writeFiles, findRepoScript,
+  mergeSettingsJson, mergeManagedMarkdown, writeFiles, writeManagedFiles, findRepoScript,
   // Version
   checkVersion,
   // Re-exports for convenience

package/lib/wizard.js

@@ -69,7 +69,7 @@ async function stepAuth(rl) {
   console.log("  0dai works in two modes:");
   console.log("");
   console.log("    Local mode  — generate configs offline, no account needed");
-  console.log("    Cloud mode  — full graph, swarm, roaming, 55 MCP tools");
+  console.log("    Cloud mode  — full graph, swarm, roaming, 56 MCP tools");
   console.log("");
 
   const answer = await ask(rl, "  Sign in now? [Y/n]: ", "y");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@0dai-dev/cli",
-  "version": "4.0.0",
-  "description": "One config layer for 5 AI agent CLIs — Claude Code, Codex, OpenCode, Gemini, Aider",
+  "version": "4.1.0",
+  "description": "One config layer for seven AI coding agents — Claude Code, Codex, OpenCode, Gemini, Aider, Qoder",
   "bin": {
     "0dai": "./bin/0dai.js"
   },
@@ -12,8 +12,11 @@
     "codex",
     "gemini",
     "aider",
+    "opencode",
+    "qoder",
     "developer-tools",
-    "mcp"
+    "mcp",
+    "cli"
   ],
   "author": "0dai-dev <dev@0dai.dev>",
   "license": "MIT",
@@ -35,7 +38,9 @@
     "README.md"
   ],
   "dependencies": {
-    "@clack/prompts": "^1.2.0",
+    "@clack/prompts": "^1.2.0"
+  },
+  "optionalDependencies": {
     "node-pty": "^1.0.0"
   }
 }