@0dai-dev/cli 4.1.0 → 4.3.4

package/lib/commands/paste.js

@@ -0,0 +1,114 @@
+"use strict";
+const shared = require("../shared");
+const { log, T, R, D, apiCall } = shared;
+
+const MAX_PASTE_BYTES = 1024 * 1024;
+
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024) {
+    const mib = bytes / (1024 * 1024);
+    return `${Number.isInteger(mib) ? mib : mib.toFixed(1)} MiB`;
+  }
+  if (bytes >= 1024) {
+    const kib = bytes / 1024;
+    return `${Number.isInteger(kib) ? kib : kib.toFixed(1)} KiB`;
+  }
+  return `${bytes} B`;
+}
+
+function readStdin({ maxBytes = MAX_PASTE_BYTES } = {}) {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      reject(new Error("no stdin — pipe text in, e.g. `cat prompt.md | 0dai paste`"));
+      return;
+    }
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdin.off("end", onEnd);
+      process.stdin.off("error", onError);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try { process.stdin.pause(); } catch {}
+      reject(error);
+    };
+    const onData = (chunk) => {
+      const text = String(chunk);
+      bytes += Buffer.byteLength(text, "utf8");
+      if (bytes > maxBytes) {
+        fail(new Error(`paste body exceeds ${formatBytes(maxBytes)} limit (received at least ${formatBytes(bytes)})`));
+        return;
+      }
+      chunks.push(text);
+    };
+    const onEnd = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(chunks.join(""));
+    };
+    const onError = (error) => fail(error);
+
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", onData);
+    process.stdin.on("end", onEnd);
+    process.stdin.on("error", onError);
+    process.stdin.resume();
+  });
+}
+
+function parseArgs(args) {
+  const out = { title: "", author: "", tags: [], quiet: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--title") out.title = args[++i] || "";
+    else if (a === "--author") out.author = args[++i] || "";
+    else if (a === "--tag") out.tags.push(args[++i] || "");
+    else if (a === "-q" || a === "--quiet") out.quiet = true;
+  }
+  return out;
+}
+
+async function cmdPaste(args) {
+  const opts = parseArgs(args);
+  let body;
+  try {
+    body = await readStdin();
+  } catch (e) {
+    console.error(`error: ${e.message}`);
+    process.exit(1);
+  }
+  if (!body || !body.trim()) {
+    console.error("error: paste body is empty");
+    process.exit(1);
+  }
+
+  const result = await apiCall("/v1/paste", {
+    body,
+    title: opts.title,
+    author: opts.author,
+    tags: opts.tags,
+  });
+
+  if (result.error) {
+    console.error(`error: ${result.error}`);
+    process.exit(1);
+  }
+
+  if (opts.quiet) {
+    console.log(result.url || result.slug || "");
+    return;
+  }
+  console.log(`${T}slug:${R} ${result.slug}`);
+  console.log(`${T}url: ${R} ${result.url}`);
+  console.log(`${T}raw: ${R} ${result.raw_url}`);
+  console.log(`${D}size: ${result.size_bytes} bytes${R}`);
+}
+
+module.exports = { cmdPaste, readStdin, parseArgs, MAX_PASTE_BYTES, formatBytes };

package/lib/commands/persona-simulate.js

@@ -0,0 +1,19 @@
+"use strict";
+const shared = require("../shared");
+const { log, D, R, spawnSync, findRepoScript } = shared;
+
+function cmdPersonaSimulate(target, args) {
+  const script = findRepoScript(target, "persona_simulate.py");
+  if (!script) {
+    log("persona-simulate unavailable in this environment");
+    console.log(`  ${D}Expected scripts/persona_simulate.py in repo checkout${R}`);
+    process.exit(1);
+  }
+
+  const forwarded = [script, ...args, "--target", target];
+  const result = spawnSync("python3", forwarded, { stdio: "inherit" });
+  if (typeof result.status === "number") process.exit(result.status);
+  process.exit(1);
+}
+
+module.exports = { cmdPersonaSimulate };

package/lib/commands/play.js

@@ -0,0 +1,173 @@
+"use strict";
+// Play Book CLI — curated plays come from the server-side registry
+// (/v1/plays, gated by plan). Local plays live under ai/plays/ inside
+// the project and support fork/rank/preview via scripts/play_book.py.
+//
+// Subcommands:
+//   0dai play list                  # curated plays (server) + local (disk)
+//   0dai play get <slug>            # show details of one play
+//   0dai play search <query…>       # substring search over local + server
+//   0dai play fork <slug> --as <new> --author <handle>
+//   0dai play run <slug> [--var K=V …]
+//   0dai play rank                  # local-only ranking (uses ai/outcomes if present)
+const shared = require("../shared");
+const { log, T, R, D, apiCall } = shared;
+const { spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+function findRepoScript(target, name) {
+  const candidates = [
+    path.join(target, "scripts", name),
+    path.join(__dirname, "../../../../scripts", name),
+    path.join("/root/0dai/scripts", name),
+  ];
+  for (const c of candidates) {
+    try { if (fs.existsSync(c)) return c; } catch {}
+  }
+  return null;
+}
+
+function runLocal(target, args) {
+  const script = findRepoScript(target, "play_book.py");
+  if (!script) return { ok: false, error: "play_book.py not found locally" };
+  const res = spawnSync("python3", [script, "--root", target, ...args], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (res.status !== 0) {
+    return { ok: false, error: (res.stderr || res.stdout || "").trim() };
+  }
+  try { return { ok: true, data: JSON.parse(res.stdout || "[]") }; }
+  catch { return { ok: true, data: res.stdout }; }
+}
+
+function fmtTags(tags) {
+  if (!tags || !tags.length) return `${D}—${R}`;
+  return tags.slice(0, 6).map(t => `${D}#${t}${R}`).join(" ");
+}
+
+async function cmdList(target) {
+  log("curated (server):");
+  const remote = await apiCall("/v1/plays");
+  if (remote && Array.isArray(remote.plays) && remote.plays.length) {
+    for (const p of remote.plays) {
+      console.log(`  ${T}${(p.slug || "").padEnd(28)}${R} ${p.title || ""} ${fmtTags(p.stacks)}`);
+    }
+    if (remote.plan && remote.plan !== "pro" && remote.plan !== "team") {
+      console.log(`  ${D}plan: ${remote.plan} — some plays locked; upgrade at /pricing${R}`);
+    }
+  } else {
+    log(`no curated plays available (plan: ${remote && remote.plan || "?"})`);
+  }
+
+  const local = runLocal(target, ["list"]);
+  if (local.ok && Array.isArray(local.data) && local.data.length) {
+    console.log("");
+    log("local (this repo):");
+    for (const p of local.data) {
+      const origin = p.parent ? `← ${p.parent}` : "original";
+      console.log(`  ${T}${(p.slug || "").padEnd(28)}${R} ${p.title || ""}  ${D}${origin}${R}`);
+    }
+  }
+}
+
+async function cmdGet(target, slug) {
+  if (!slug) { log("usage: 0dai play get <slug>"); return; }
+  // Try remote first (curated), fall back to local
+  const remote = await apiCall(`/v1/plays/${encodeURIComponent(slug)}`);
+  if (remote && !remote.error) {
+    console.log(JSON.stringify(remote, null, 2));
+    return;
+  }
+  const local = runLocal(target, ["get", slug]);
+  if (local.ok) {
+    console.log(typeof local.data === "string" ? local.data : JSON.stringify(local.data, null, 2));
+    return;
+  }
+  log(`not found on server or locally: ${slug}`);
+  process.exit(1);
+}
+
+async function cmdSearch(target, query) {
+  if (!query) { log("usage: 0dai play search <query>"); return; }
+  const remote = await apiCall("/v1/plays");
+  const q = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const hits = [];
+  if (remote && Array.isArray(remote.plays)) {
+    for (const p of remote.plays) {
+      const hay = [p.slug, p.title, p.description, ...(p.stacks || [])].join(" ").toLowerCase();
+      if (q.every(t => hay.includes(t))) hits.push({ origin: "server", ...p });
+    }
+  }
+  const local = runLocal(target, ["search", ...query.split(/\s+/)]);
+  if (local.ok && Array.isArray(local.data)) {
+    for (const p of local.data) hits.push({ origin: "local", ...p });
+  }
+  if (!hits.length) { log("no matches"); return; }
+  for (const h of hits) {
+    console.log(`  ${T}[${h.origin}]${R} ${(h.slug || "").padEnd(26)} ${h.title || ""}`);
+  }
+}
+
+function cmdFork(target, slug, args) {
+  if (!slug) { log("usage: 0dai play fork <slug> --as <new-slug> --author <handle>"); return; }
+  const newSlug = argAfter(args, "--as");
+  const author = argAfter(args, "--author");
+  if (!newSlug || !author) { log("fork requires --as <new-slug> --author <handle>"); return; }
+  const res = runLocal(target, ["fork", slug, "--as", newSlug, "--author", author]);
+  if (!res.ok) { log(`fork failed: ${res.error}`); process.exit(1); }
+  console.log(typeof res.data === "string" ? res.data : JSON.stringify(res.data, null, 2));
+}
+
+function cmdRun(target, slug, args) {
+  if (!slug) { log("usage: 0dai play run <slug> [--var K=V …]"); return; }
+  const fwdArgs = ["run", slug];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--var" && args[i + 1]) { fwdArgs.push("--var", args[i + 1]); i++; }
+  }
+  const res = runLocal(target, fwdArgs);
+  if (!res.ok) { log(`run failed: ${res.error}`); process.exit(1); }
+  console.log(typeof res.data === "string" ? res.data : JSON.stringify(res.data, null, 2));
+}
+
+function cmdRank(target, args) {
+  const fwdArgs = ["rank"];
+  const outcomes = argAfter(args, "--outcomes");
+  if (outcomes) fwdArgs.push("--outcomes", outcomes);
+  const res = runLocal(target, fwdArgs);
+  if (!res.ok) { log(`rank failed: ${res.error}`); process.exit(1); }
+  console.log(typeof res.data === "string" ? res.data : JSON.stringify(res.data, null, 2));
+}
+
+function argAfter(args, flag) {
+  const i = args.indexOf(flag);
+  return i >= 0 && i + 1 < args.length ? args[i + 1] : null;
+}
+
+async function cmdPlay(target, sub, args) {
+  const remaining = args.slice(2);
+  if (!sub || sub === "help") {
+    console.log("Usage: 0dai play <command>");
+    console.log("  list                       Show curated + local plays");
+    console.log("  get <slug>                 Show one play");
+    console.log("  search <query…>            Search curated + local");
+    console.log("  fork <slug> --as <new> --author <you>  Fork into local");
+    console.log("  run <slug> [--var K=V …]   Preview rendered steps");
+    console.log("  rank [--outcomes FILE]     Rank local plays by success rate");
+    return;
+  }
+  switch (sub) {
+    case "list": return cmdList(target);
+    case "get": return cmdGet(target, args[1]);
+    case "search": return cmdSearch(target, args.slice(1).join(" "));
+    case "fork": return cmdFork(target, args[1], remaining);
+    case "run": return cmdRun(target, args[1], remaining);
+    case "rank": return cmdRank(target, remaining);
+    default:
+      log(`unknown subcommand: ${sub}`);
+      return cmdPlay(target, "help", []);
+  }
+}
+
+module.exports = { cmdPlay };

package/lib/commands/provider.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const shared = require("../shared");
+const { log, spawnSync, findRepoScript } = shared;
+
+function cmdProvider(target, args) {
+  // Check for per-repo provider commands first
+  const subcommand = args[0] || "";
+
+  if (subcommand === "list" || subcommand === "switch" || subcommand === "clear") {
+    // New per-repo provider profile commands — use provider_registry.py
+    const script = findRepoScript(target, "provider_registry_cli.py");
+    if (!script) {
+      // Fallback: inline Python call to provider_registry module
+      const pyCode = `
+import sys
+import json
+import pathlib
+sys.path.insert(0, '${target}/scripts')
+import provider_registry as pr
+
+target = pathlib.Path('${target}')
+args = ${JSON.stringify(args)}
+subcmd = args[0] if args else 'list'
+
+try:
+    if subcmd == 'list':
+        providers = pr.list_providers_for_repo(target)
+        print('Provider Status for', target.name)
+        print('=' * 60)
+        for p in providers:
+            active = '→' if p['active'] else ' '
+            source = f"[{p['source']}]" if p['source'] else ''
+            creds = '✓' if p['has_credentials'] else '✗'
+            print(f"  {active} {p['name']:<12} {creds} creds  {source:<10} {p['base_url']}")
+        print()
+        try:
+            resolved = pr.resolve_for_repo(target)
+            print(f"Active: {resolved['provider_name']} (source={resolved['source']})")
+        except pr.ProviderRegistryError as e:
+            print(f"No active provider: {e}")
+    elif subcmd == 'switch':
+        provider_name = ''
+        for i, a in enumerate(args):
+            if a == '--provider' and i + 1 < len(args):
+                provider_name = args[i + 1]
+        if not provider_name:
+            print('Usage: 0dai provider switch --target . --provider NAME')
+            sys.exit(1)
+        result = pr.switch_provider(target, provider_name)
+        print(f"Switched {target.name} to provider: {result['provider_name']}")
+        print(f"  base_url: {result['base_url']}")
+        print(f"  audit log: ~/.0dai/audit/provider-changes.jsonl")
+    elif subcmd == 'clear':
+        cleared = pr.clear_repo_profile(target)
+        if cleared:
+            print(f"Cleared per-repo profile for {target.name}")
+            print(f"Will fall back to global default or env vars")
+        else:
+            print(f"No per-repo profile to clear for {target.name}")
+except pr.ProviderRegistryError as e:
+    print(f"Error: {e}")
+    sys.exit(1)
+`;
+      const result = spawnSync("python3", ["-c", pyCode], { stdio: "inherit" });
+      if (typeof result.status === "number") process.exit(result.status);
+      process.exit(1);
+    }
+    const forwarded = [script, ...args];
+    const result = spawnSync("python3", forwarded, { stdio: "inherit" });
+    if (typeof result.status === "number") process.exit(result.status);
+    process.exit(1);
+  }
+
+  // Legacy provider_profiles.py commands
+  const script = findRepoScript(target, "provider_profiles.py");
+  if (!script) {
+    log("provider profiles unavailable in this environment");
+    process.exit(1);
+  }
+  const forwarded = [script, ...args];
+  const result = spawnSync("python3", forwarded, { stdio: "inherit" });
+  if (typeof result.status === "number") process.exit(result.status);
+  process.exit(1);
+}
+
+module.exports = { cmdProvider };

package/lib/commands/quota.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const shared = require("../shared");
+const { log, T, R, D, E, W, G, fs, path, spawnSync, findRepoScript } = shared;
+
+function _color(pct) {
+  if (pct == null) return D;
+  if (pct >= 95) return E;
+  if (pct >= 80) return W;
+  return G;
+}
+
+function _bar(pct, width = 20) {
+  if (pct == null) return D + "—".repeat(width) + R;
+  const filled = Math.min(width, Math.max(0, Math.round((pct / 100) * width)));
+  const empty = width - filled;
+  return _color(pct) + "█".repeat(filled) + R + D + "░".repeat(empty) + R;
+}
+
+function _pad(s, n) { s = String(s); return s + " ".repeat(Math.max(0, n - s.length)); }
+
+function _loadEnvelope(target, opts = {}) {
+  const cachePath = path.join(target, "ai", "manifest", "agent-quotas.json");
+  const force = !!opts.refresh;
+  const script = findRepoScript(target, "agent_quotas.py");
+  if (script) {
+    const args = [script, "--target", target, "--json"];
+    if (force) args.push("--refresh");
+    const r = spawnSync("python3", args, {
+      encoding: "utf8",
+      timeout: 30000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (r.status === 0 && r.stdout) {
+      try { return JSON.parse(r.stdout); } catch {}
+    }
+  }
+  if (fs.existsSync(cachePath)) {
+    try { return JSON.parse(fs.readFileSync(cachePath, "utf8")); } catch {}
+  }
+  return { fetched_at: 0, fetched_at_iso: null, ttl_seconds: 600, agents: {} };
+}
+
+function cmdQuota(target, args = []) {
+  const opts = {
+    refresh: args.includes("--refresh") || args.includes("-r"),
+    json: args.includes("--json"),
+  };
+  const envelope = _loadEnvelope(target, opts);
+  if (opts.json) {
+    console.log(JSON.stringify(envelope, null, 2));
+    return envelope;
+  }
+  const agents = envelope.agents || {};
+  const known = ["codex", "qoder", "claude", "opencode", "gemini", "capi"];
+  log(`Agent quotas (cached ${envelope.fetched_at_iso || "never"}, ttl=${envelope.ttl_seconds || 600}s)`);
+  console.log("");
+  console.log(
+    `  ${_pad("AGENT", 10)} ${_pad("PLAN", 14)} ${_pad("WEEK%", 7)} ${_pad("HOUR%", 7)} ${_pad("BAR (weekly)", 22)} SOURCE`,
+  );
+  for (const a of known) {
+    const rec = agents[a] || { plan: "unknown", weekly_pct_used: null, hourly_pct_used: null, source: null, error: "no data" };
+    const weekly = rec.weekly_pct_used;
+    const hourly = rec.hourly_pct_used;
+    const bar = _bar(weekly);
+    const wstr = weekly == null ? `${D}—${R}` : `${_color(weekly)}${weekly}%${R}`;
+    const hstr = hourly == null ? `${D}—${R}` : `${_color(hourly)}${hourly}%${R}`;
+    const src = rec.source || rec.error || "—";
+    console.log(`  ${_pad(a, 10)} ${_pad(rec.plan || "unknown", 14)} ${_pad(wstr, 7)} ${_pad(hstr, 7)} ${bar}  ${D}${src}${R}`);
+  }
+  console.log("");
+  console.log(`  ${D}Yellow >80% · Red >95% (skipped by dispatcher) · '0dai quota --refresh' forces re-poll${R}`);
+  return envelope;
+}
+
+module.exports = { cmdQuota };

package/lib/commands/receipt.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * `0dai receipt` — shareable PNG receipt for a 0dai session.
+ *
+ * Reads session telemetry from ai/sessions + ai/experience/events via
+ * scripts/receipt_png.py, saves a 1200×630 OG image to ~/.0dai/receipts/,
+ * and copies it to the system clipboard (pbcopy / xclip / wl-copy).
+ *
+ * Issue: #529 (The Bill)
+ */
+const shared = require("../shared");
+const { log, D, R, findRepoScript, spawnSync } = shared;
+
+function _findArg(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx < 0 || !args[idx + 1]) return null;
+  return args[idx + 1];
+}
+
+function cmdReceipt(target, args) {
+  const script = findRepoScript(target, "receipt_png.py");
+  if (!script) {
+    log("receipt generator unavailable — missing scripts/receipt_png.py");
+    console.log(`  ${D}Run from a 0dai-initialized project root.${R}`);
+    return;
+  }
+
+  const fwd = [script, "--target", target];
+
+  const sessionId = _findArg(args, "--session");
+  if (sessionId) {
+    fwd.push("--session", sessionId);
+  } else if (args.includes("--active")) {
+    fwd.push("--active");
+  } else {
+    // Default: --last (matches the acceptance criterion in #529).
+    fwd.push("--last");
+  }
+
+  const output = _findArg(args, "--output");
+  if (output) fwd.push("--output", output);
+
+  if (args.includes("--no-clipboard")) fwd.push("--no-clipboard");
+  if (args.includes("--json")) fwd.push("--json");
+  if (args.includes("--stats-only")) fwd.push("--stats-only");
+
+  const result = spawnSync("python3", fwd, { stdio: "inherit" });
+  if (typeof result.status === "number" && result.status !== 0) {
+    process.exit(result.status);
+  }
+}
+
+module.exports = { cmdReceipt };

package/lib/commands/report.js

@@ -1,8 +1,9 @@
 "use strict";
 const shared = require("../shared");
-const { log, D, R, spawnSync, findRepoScript, VERSION } = shared;
+const { log, D, R, T, spawnSync, findRepoScript, VERSION } = shared;
+const { confirmOrExit, shouldAutoYes } = require("../utils/diff-preview");
 
-function cmdReport(target, sub, args) {
+async function cmdReport(target, sub, args) {
   const reportScript = findRepoScript(target, "report_manager.py");
   if (!reportScript) {
     log("report manager unavailable in this environment");
@@ -11,6 +12,32 @@ function cmdReport(target, sub, args) {
   }
 
   const command = sub || "preview";
+
+  if (command === "push") {
+    const skipPreview = args.includes("--no-preview");
+    const dryRun = args.includes("--dry-run");
+    if (!skipPreview) {
+      const previewArgs = [reportScript, "preview", "--target", target, "--channel", "npm", "--cli-version", VERSION];
+      log(`${T}preview of report payload before push:${R}`);
+      const preview = spawnSync("python3", previewArgs, { stdio: "inherit" });
+      if (typeof preview.status === "number" && preview.status !== 0) {
+        log("preview failed; aborting push");
+        process.exit(preview.status);
+      }
+    }
+    if (dryRun) {
+      log(`${D}dry-run: would push the report shown above. Re-run without --dry-run to send.${R}`);
+      return;
+    }
+    if (!shouldAutoYes(args)) {
+      const ok = await confirmOrExit({ args, message: "Push this report to 0dai cloud?", defaultYes: false });
+      if (!ok) {
+        log("push aborted by user");
+        return;
+      }
+    }
+  }
+
   const forwarded = [reportScript, command, "--target", target, "--channel", "npm", "--cli-version", VERSION];
 
   if (args.includes("--json")) forwarded.push("--json");

package/lib/commands/run.js

@@ -4,7 +4,7 @@ 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(`Usage: 0dai run <goal> [--dry-run] [--agent claude|codex|gemini] [--provider deepseek|gemini-direct|codex|claude-opus]`);
     console.log(`  Example: 0dai run "add dark mode to settings page"`);
     return;
   }
@@ -12,6 +12,15 @@ async function cmdRun(goal, target, args = []) {
   const dryRun = args.includes("--dry-run");
   const agentIdx = args.indexOf("--agent");
   const agentOverride = agentIdx >= 0 ? args[agentIdx + 1] : null;
+  const providerIdx = args.indexOf("--provider");
+  const providerOverride = providerIdx >= 0 ? normalizeProvider(args[providerIdx + 1] || "") : null;
+  const providerModelIdx = args.indexOf("--provider-model");
+  const providerModel = providerModelIdx >= 0 ? (args[providerModelIdx + 1] || "") : "";
+
+  if (providerIdx >= 0 && !providerOverride) {
+    log("error: unsupported provider. Supported: deepseek, gemini-direct, codex, claude-opus, claude-sonnet");
+    return;
+  }
 
   // Read project context
   let stack = "generic", agents = ["claude"], commands = {};
@@ -35,9 +44,10 @@ async function cmdRun(goal, target, args = []) {
 
   for (let i = 0; i < tasks.length; i++) {
     const t = tasks[i];
-    const agent = agentOverride || t.assigned_to;
+    const agent = agentOverride || providerAgent(providerOverride) || t.assigned_to;
     console.log(`  ${T}${i + 1}.${R} ${t.title}`);
-    console.log(`     ${D}→ ${agent}  [${t.model_tier}]${t.description ? "  " + t.description : ""}${R}`);
+    const providerText = providerOverride ? ` via ${providerOverride}` : "";
+    console.log(`     ${D}→ ${agent}${providerText}  [${t.model_tier}]${t.description ? "  " + t.description : ""}${R}`);
   }
 
   if (dryRun) {
@@ -58,12 +68,18 @@ async function cmdRun(goal, target, args = []) {
       id,
       title: t.title,
       description: t.description || "",
-      assigned_to: agentOverride || t.assigned_to,
+      assigned_to: agentOverride || providerAgent(providerOverride) || t.assigned_to,
       model_tier: t.model_tier,
       created_by: "run",
       created_at: new Date().toISOString(),
       context: { goal },
     };
+    if (providerOverride) {
+      entry.provider_override = providerOverride;
+      entry.provider = providerOverride;
+      entry.provider_source = "cli_override";
+      if (providerModel) entry.provider_model = providerModel;
+    }
     try {
       fs.writeFileSync(path.join(queueDir, `${id}.json`), JSON.stringify(entry, null, 2));
       created.push(id);
@@ -74,4 +90,28 @@ async function cmdRun(goal, target, args = []) {
   console.log(`  ${D}Monitor: 0dai watch  |  Queue: 0dai swarm status${R}\n`);
 }
 
+function normalizeProvider(provider) {
+  const key = String(provider || "").trim().toLowerCase().replace(/_/g, "-");
+  const aliases = {
+    "deepseek": "deepseek",
+    "gemini": "gemini-direct",
+    "gemini-direct": "gemini-direct",
+    "gemini-1.5": "gemini-direct",
+    "codex": "codex",
+    "claude-opus": "claude-opus",
+    "opus": "claude-opus",
+    "claude-sonnet": "claude-sonnet",
+    "sonnet": "claude-sonnet",
+  };
+  return aliases[key] || "";
+}
+
+function providerAgent(provider) {
+  if (provider === "deepseek") return "deepseek";
+  if (provider === "gemini-direct") return "gemini";
+  if (provider === "codex") return "codex";
+  if (provider === "claude-opus" || provider === "claude-sonnet") return "claude";
+  return null;
+}
+
 module.exports = { cmdRun };