@0dai-dev/cli 4.2.0 → 4.3.5

package/lib/commands/loop.js

@@ -0,0 +1,108 @@
+"use strict";
+
+/**
+ * `0dai loop ack` — operator acknowledgement stub for the proactive loop
+ * (issue #2235).
+ *
+ * This is intentionally a sketch. v1 only writes one JSON line to
+ * `ai/meta/telemetry/operator-ack.jsonl`. There is no server round-trip,
+ * no signed token, no rate-limit. The dead man's switch (Python side,
+ * `scripts/dead_man_switch.py`) reads that file and pauses the loop if
+ * the most recent ack is older than 24h.
+ *
+ * TODO (v1.1): authenticate the ack against the 0dai control plane so an
+ *   ack from a stolen developer machine cannot un-pause the loop.
+ * TODO (v1.1): print the most recent ack timestamp + the time until the
+ *   dead-man would trip again, so the operator sees the runway.
+ * TODO (v1.x): expose `0dai loop status` and `0dai loop pause`.
+ */
+
+const shared = require("../shared");
+const { log, T, R, D, fs, path } = shared;
+
+function nowIso() {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+function detectOpId() {
+  // Best-effort identity. We do not exfiltrate this anywhere — it stays in a
+  // local jsonl. Order: $ODAI_OP_ID, $USER, $LOGNAME, "unknown".
+  return process.env.ODAI_OP_ID
+    || process.env.USER
+    || process.env.LOGNAME
+    || "unknown";
+}
+
+function ackPath(target) {
+  return path.join(target, "ai", "meta", "telemetry", "operator-ack.jsonl");
+}
+
+function cmdLoopAck(target, args) {
+  const noteIdx = args.indexOf("--note");
+  const note = noteIdx >= 0 && args[noteIdx + 1] ? args[noteIdx + 1] : "";
+
+  const file = ackPath(target);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+  } catch (e) {
+    log(`error: cannot create telemetry dir: ${e.message}`);
+    process.exit(1);
+  }
+
+  const entry = { ts: nowIso(), op_id: detectOpId() };
+  if (note) entry.note = note.slice(0, 240);
+
+  try {
+    fs.appendFileSync(file, JSON.stringify(entry) + "\n");
+  } catch (e) {
+    log(`error: cannot write ack: ${e.message}`);
+    process.exit(1);
+  }
+
+  log(`${T}loop ack${R} recorded at ${entry.ts} (op_id=${entry.op_id})`);
+  console.log(`  ${D}wrote ${file}${R}`);
+  console.log(`  ${D}TODO v1.1: server-side ack + signed token${R}`);
+}
+
+function cmdLoopStatus(target) {
+  const file = ackPath(target);
+  if (!fs.existsSync(file)) {
+    log("no ack history yet — run `0dai loop ack` to start the dead-man clock");
+    return;
+  }
+  let lastTs = null;
+  try {
+    const lines = fs.readFileSync(file, "utf8").trim().split("\n").filter(Boolean);
+    for (const ln of lines) {
+      try {
+        const row = JSON.parse(ln);
+        if (row && row.ts) lastTs = row.ts;
+      } catch { /* ignore malformed */ }
+    }
+  } catch (e) {
+    log(`error: cannot read ack file: ${e.message}`);
+    process.exit(1);
+  }
+  if (!lastTs) {
+    log("ack file present but no parsable rows");
+    return;
+  }
+  const ageMs = Date.now() - new Date(lastTs).getTime();
+  const ageHours = (ageMs / 3_600_000).toFixed(1);
+  log(`last ack: ${lastTs} (${ageHours}h ago)`);
+  console.log(`  ${D}dead-man trips at 24h since last ack${R}`);
+}
+
+function cmdLoop(target, sub, args) {
+  const subArgs = args.slice(2);
+  if (sub === "ack") return cmdLoopAck(target, subArgs);
+  if (sub === "status") return cmdLoopStatus(target);
+  console.log("Usage: 0dai loop [ack [--note '...'] | status]");
+  console.log("");
+  console.log("  ack     Refresh dead-man-switch operator ack timestamp");
+  console.log("  status  Show last ack and runway until dead-man trips");
+  console.log("");
+  console.log(`  ${D}see ai/docs/proactive-loop-v1.md for the full design${R}`);
+}
+
+module.exports = { cmdLoop, cmdLoopAck, cmdLoopStatus };

package/lib/commands/mcp.js

@@ -0,0 +1,410 @@
+"use strict";
+
+/**
+ * `0dai mcp` — inspect and test the project's MCP server surface.
+ *
+ * Subcommands (all read-only / inspection):
+ *   - list [--plan free|pro|team|enterprise] [--json]
+ *       Enumerate MCP tools exposed by scripts/mcp_server.py.
+ *       Resolves from ai/meta/manifest/mcp-tool-tiers.json when present,
+ *       falls back to scanning @mcp.tool decorators in scripts/mcp_server.py.
+ *   - catalog [--stack NAME] [--json]
+ *       Show the per-stack MCP server catalog (common + stack servers)
+ *       from templates/layer/ai/registry/mcp-catalog.json.
+ *   - doctor [--json]
+ *       Verify .mcp.json + server script reachability + plan visibility.
+ *   - call <tool> [--json '<args>'] [--json-out]
+ *       Invoke a single MCP tool synchronously via scripts/mcp_server.py
+ *       (no daemon spawn — direct in-process call inside the helper subprocess).
+ *
+ * This command never mutates project state. It is the documented
+ * counterpart of the `mcp list` / `mcp call` / `mcp catalog` docs and the
+ * missing dispatch surface flagged by issue #2414.
+ */
+
+const shared = require("../shared");
+const { T, R, D, G, W, log, fs, path, spawnSync, findRepoScript } = shared;
+
+function _printHelp() {
+  console.log(`\n  ${T}0dai mcp${R} — inspect MCP tool surface\n`);
+  console.log("Usage:");
+  console.log("  0dai mcp list     [--plan free|pro|team|enterprise] [--json]");
+  console.log("  0dai mcp catalog  [--stack NAME] [--json]");
+  console.log("  0dai mcp doctor   [--json]");
+  console.log("  0dai mcp call <tool> [--json '<json-args>'] [--json-out]");
+  console.log("");
+  console.log("Read-only inspection of the project's MCP server (scripts/mcp_server.py).");
+  console.log("");
+}
+
+function _argAfter(args, name) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === name && args[i + 1]) return args[i + 1];
+  }
+  return "";
+}
+
+function _normalizePlan(raw) {
+  const p = String(raw || "").toLowerCase().trim();
+  if (!p) return "free";
+  if (["free", "pro", "team", "enterprise"].includes(p)) return p;
+  return "free";
+}
+
+function _readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (e) {
+    return null;
+  }
+}
+
+function _toolsFromTierManifest(target, plan) {
+  const candidates = [
+    path.join(target, "ai", "meta", "manifest", "mcp-tool-tiers.json"),
+    path.join(target, "ai", "manifest", "mcp-tool-tiers.json"),
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    const data = _readJsonFile(candidate);
+    if (!data || typeof data !== "object") continue;
+    const exposure = data.exposure || {};
+    const section = exposure[plan] || exposure.free;
+    if (!section) continue;
+    const tools = Array.isArray(section.tools) ? section.tools.slice() : [];
+    return { source: candidate, plan, tools, count: tools.length };
+  }
+  return null;
+}
+
+function _toolsByScanning(target) {
+  const script = findRepoScript(target, "mcp_server.py");
+  if (!script) return null;
+  let text;
+  try { text = fs.readFileSync(script, "utf8"); } catch { return null; }
+  const tools = [];
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() !== "@mcp.tool") continue;
+    // find next `def NAME(...)`
+    for (let j = i + 1; j < Math.min(i + 6, lines.length); j++) {
+      const m = lines[j].match(/^def\s+([A-Za-z_][A-Za-z0-9_]*)/);
+      if (m) { tools.push(m[1]); break; }
+    }
+  }
+  return { source: script, plan: "scan", tools, count: tools.length };
+}
+
+function _cmdList(target, args) {
+  const wantJson = args.includes("--json");
+  const plan = _normalizePlan(_argAfter(args, "--plan"));
+
+  let result = _toolsFromTierManifest(target, plan);
+  if (!result) result = _toolsByScanning(target);
+  if (!result) {
+    if (wantJson) {
+      console.log(JSON.stringify({ error: "no MCP tool source resolved", tools: [], count: 0 }));
+    } else {
+      log("no MCP tool source resolved (expected ai/meta/manifest/mcp-tool-tiers.json or scripts/mcp_server.py)");
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  if (wantJson) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+
+  console.log(`\n  ${T}0dai mcp list${R}  source=${result.source}  plan=${result.plan}  count=${result.count}\n`);
+  for (const tool of result.tools) console.log(`  ${G}•${R} ${tool}`);
+  console.log("");
+}
+
+function _resolveCatalogPath(target) {
+  const candidates = [
+    path.join(target, "ai", "registry", "mcp-catalog.json"),
+    path.join(target, "templates", "layer", "ai", "registry", "mcp-catalog.json"),
+  ];
+  // Also look next to the npm package (when run from a sync'd repo elsewhere).
+  const repoRoot = path.resolve(__dirname, "..", "..", "..", "..");
+  candidates.push(path.join(repoRoot, "templates", "layer", "ai", "registry", "mcp-catalog.json"));
+  candidates.push(path.join(repoRoot, "ai", "registry", "mcp-catalog.json"));
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+
+function _detectStack(target) {
+  const candidates = [
+    path.join(target, "ai", "manifest", "discovery.json"),
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    const data = _readJsonFile(candidate);
+    if (data && typeof data.stack === "string" && data.stack) return data.stack;
+  }
+  return "generic";
+}
+
+function _cmdCatalog(target, args) {
+  const wantJson = args.includes("--json");
+  const stackArg = _argAfter(args, "--stack");
+  const catalogPath = _resolveCatalogPath(target);
+  if (!catalogPath) {
+    if (wantJson) console.log(JSON.stringify({ error: "MCP catalog not found" }));
+    else log("MCP catalog not found (expected ai/registry/mcp-catalog.json or templates/layer/ai/registry/mcp-catalog.json)");
+    process.exitCode = 1;
+    return;
+  }
+  const catalog = _readJsonFile(catalogPath);
+  if (!catalog) {
+    if (wantJson) console.log(JSON.stringify({ error: "MCP catalog not parseable", path: catalogPath }));
+    else log(`MCP catalog not parseable: ${catalogPath}`);
+    process.exitCode = 1;
+    return;
+  }
+  const stack = stackArg || _detectStack(target);
+  const common = catalog.common || {};
+  const stacks = catalog.stacks || {};
+  const stackEntry = stacks[stack] || {};
+  const stackServers = stackEntry.servers || {};
+  const available = Object.keys(stacks).sort();
+
+  if (wantJson) {
+    const commonOut = {};
+    for (const [k, v] of Object.entries(common)) commonOut[k] = (v && v.description) || "";
+    const stackOut = {};
+    for (const [k, v] of Object.entries(stackServers)) stackOut[k] = (v && v.description) || "";
+    console.log(JSON.stringify({
+      stack,
+      source: catalogPath,
+      common_servers: commonOut,
+      stack_servers: stackOut,
+      available_stacks: available,
+    }));
+    return;
+  }
+
+  console.log(`\n  ${T}0dai mcp catalog${R}  source=${catalogPath}  stack=${stack}\n`);
+  console.log(`  ${T}common servers${R}`);
+  for (const [name, entry] of Object.entries(common)) {
+    console.log(`    ${G}•${R} ${name} ${D}— ${(entry && entry.description) || ""}${R}`);
+  }
+  console.log(`\n  ${T}stack servers${R} (${stack})`);
+  if (!Object.keys(stackServers).length) {
+    console.log(`    ${D}(none)${R}`);
+  } else {
+    for (const [name, entry] of Object.entries(stackServers)) {
+      console.log(`    ${G}•${R} ${name} ${D}— ${(entry && entry.description) || ""}${R}`);
+    }
+  }
+  console.log(`\n  ${T}available stacks${R}: ${available.join(", ")}\n`);
+}
+
+function _cmdDoctor(target, args) {
+  const wantJson = args.includes("--json");
+  const report = {
+    target,
+    server_script: { path: "", ok: false },
+    mcp_config: { path: "", ok: false, servers: [] },
+    tier_manifest: { path: "", ok: false, free_count: 0, pro_count: 0 },
+    catalog: { path: "", ok: false, stacks: 0 },
+  };
+
+  const script = findRepoScript(target, "mcp_server.py");
+  if (script) {
+    report.server_script.path = script;
+    report.server_script.ok = fs.existsSync(script);
+  }
+
+  const mcpJson = path.join(target, ".mcp.json");
+  if (fs.existsSync(mcpJson)) {
+    report.mcp_config.path = mcpJson;
+    const data = _readJsonFile(mcpJson);
+    if (data && data.mcpServers && typeof data.mcpServers === "object") {
+      report.mcp_config.ok = true;
+      report.mcp_config.servers = Object.keys(data.mcpServers);
+    }
+  }
+
+  const tierCandidates = [
+    path.join(target, "ai", "meta", "manifest", "mcp-tool-tiers.json"),
+    path.join(target, "ai", "manifest", "mcp-tool-tiers.json"),
+  ];
+  for (const candidate of tierCandidates) {
+    if (!fs.existsSync(candidate)) continue;
+    const data = _readJsonFile(candidate);
+    if (!data || !data.exposure) continue;
+    report.tier_manifest.path = candidate;
+    report.tier_manifest.ok = true;
+    const free = data.exposure.free;
+    const pro = data.exposure.pro;
+    if (free && Array.isArray(free.tools)) report.tier_manifest.free_count = free.tools.length;
+    if (pro && Array.isArray(pro.tools)) report.tier_manifest.pro_count = pro.tools.length;
+    break;
+  }
+
+  const catalogPath = _resolveCatalogPath(target);
+  if (catalogPath) {
+    const data = _readJsonFile(catalogPath);
+    if (data) {
+      report.catalog.path = catalogPath;
+      report.catalog.ok = true;
+      report.catalog.stacks = Object.keys(data.stacks || {}).length;
+    }
+  }
+
+  if (wantJson) {
+    console.log(JSON.stringify(report));
+    return;
+  }
+
+  const ok = (b) => (b ? G + "ok" + R : W + "missing" + R);
+  console.log(`\n  ${T}0dai mcp doctor${R}  target=${target}\n`);
+  console.log(`  server script   ${ok(report.server_script.ok)}  ${D}${report.server_script.path || "(not found)"}${R}`);
+  console.log(`  .mcp.json       ${ok(report.mcp_config.ok)}  ${D}${report.mcp_config.path || "(not found)"}${R}`);
+  if (report.mcp_config.ok) {
+    console.log(`    servers: ${report.mcp_config.servers.join(", ")}`);
+  }
+  console.log(`  tier manifest   ${ok(report.tier_manifest.ok)}  ${D}${report.tier_manifest.path || "(not found)"}${R}`);
+  if (report.tier_manifest.ok) {
+    console.log(`    free=${report.tier_manifest.free_count} pro=${report.tier_manifest.pro_count}`);
+  }
+  console.log(`  catalog         ${ok(report.catalog.ok)}  ${D}${report.catalog.path || "(not found)"}${R}`);
+  if (report.catalog.ok) {
+    console.log(`    stacks: ${report.catalog.stacks}`);
+  }
+  console.log("");
+
+  const allOk = report.server_script.ok && report.mcp_config.ok && (report.tier_manifest.ok || report.catalog.ok);
+  if (!allOk) process.exitCode = 1;
+}
+
+function _cmdCall(target, toolName, args) {
+  const wantJsonOut = args.includes("--json-out");
+  const jsonArgs = _argAfter(args, "--json");
+  if (!toolName) {
+    log("usage: 0dai mcp call <tool> [--json '<json-args>'] [--json-out]");
+    process.exitCode = 1;
+    return;
+  }
+
+  const script = findRepoScript(target, "mcp_server.py");
+  if (!script) {
+    log("scripts/mcp_server.py not found in this repo");
+    process.exitCode = 1;
+    return;
+  }
+
+  let parsedArgs = {};
+  if (jsonArgs) {
+    try { parsedArgs = JSON.parse(jsonArgs); }
+    catch (e) { log(`--json is not valid JSON: ${e.message}`); process.exitCode = 1; return; }
+    if (!parsedArgs || typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) {
+      log("--json must be a JSON object");
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // Run a tiny inline helper that imports the server module and invokes the
+  // named @mcp.tool function directly. We deliberately don't spin up the
+  // FastMCP stdio loop — this is debugging convenience, not the runtime path.
+  const helper = [
+    "import importlib.util, json, os, pathlib, sys",
+    "spec = importlib.util.spec_from_file_location('odai_mcp_server', sys.argv[1])",
+    "mod = importlib.util.module_from_spec(spec)",
+    "spec.loader.exec_module(mod)",
+    "target = pathlib.Path(sys.argv[2]).resolve()",
+    "if hasattr(mod, 'TARGET_DIR'): mod.TARGET_DIR = target",
+    "name = sys.argv[3]",
+    "kwargs = json.loads(sys.argv[4] or '{}')",
+    "fn = getattr(mod, name, None)",
+    "if fn is None:",
+    "    print(json.dumps({'error': f'unknown tool: {name}'}))",
+    "    sys.exit(2)",
+    "# FastMCP wraps the function but the underlying callable is still",
+    "# accessible. Try direct call first, then .fn / .func attrs.",
+    "underlying = fn",
+    "for attr in ('fn', 'func', '_func'):",
+    "    if hasattr(underlying, attr) and callable(getattr(underlying, attr)):",
+    "        underlying = getattr(underlying, attr)",
+    "        break",
+    "try:",
+    "    result = underlying(**kwargs) if callable(underlying) else None",
+    "except TypeError as e:",
+    "    print(json.dumps({'error': f'bad args for {name}: {e}'}))",
+    "    sys.exit(3)",
+    "except Exception as e:",
+    "    print(json.dumps({'error': str(e), 'tool': name}))",
+    "    sys.exit(4)",
+    "print(json.dumps(result, default=str))",
+  ].join("\n");
+
+  const r = spawnSync("python3", ["-c", helper, script, target, toolName, JSON.stringify(parsedArgs)], {
+    encoding: "utf8",
+    timeout: 30000,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  if (r.error) { log(`call failed: ${r.error.message}`); process.exitCode = 1; return; }
+  const stdout = (r.stdout || "").trim();
+  const stderr = (r.stderr || "").trim();
+
+  if (wantJsonOut) {
+    if (stdout) console.log(stdout);
+    else if (stderr) console.log(JSON.stringify({ error: stderr }));
+    if (typeof r.status === "number" && r.status !== 0) process.exitCode = r.status;
+    return;
+  }
+
+  if (stderr) console.log(`${D}${stderr}${R}`);
+  if (stdout) {
+    try {
+      const parsed = JSON.parse(stdout);
+      console.log(JSON.stringify(parsed, null, 2));
+    } catch {
+      console.log(stdout);
+    }
+  }
+  if (typeof r.status === "number" && r.status !== 0) process.exitCode = r.status;
+}
+
+function cmdMcp(target, sub, args) {
+  const restAll = Array.isArray(args) ? args : [];
+  // args here is the full argv from bin/0dai.js (already target-stripped),
+  // so restAll[0] === "mcp", restAll[1] === sub. Forwarded options are restAll.slice(2).
+  const rest = restAll.slice(2);
+  const command = (sub || "").toLowerCase();
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    _printHelp();
+    return;
+  }
+
+  switch (command) {
+    case "list":
+      _cmdList(target, rest);
+      return;
+    case "catalog":
+      _cmdCatalog(target, rest);
+      return;
+    case "doctor":
+      _cmdDoctor(target, rest);
+      return;
+    case "call": {
+      const toolName = rest[0] && !rest[0].startsWith("-") ? rest[0] : "";
+      const callArgs = toolName ? rest.slice(1) : rest;
+      _cmdCall(target, toolName, callArgs);
+      return;
+    }
+    default:
+      log(`unknown mcp subcommand: ${command}`);
+      _printHelp();
+      process.exitCode = 1;
+  }
+}
+
+module.exports = { cmdMcp };

package/lib/commands/models.js

@@ -8,15 +8,29 @@ const {
 } = require("../utils/model_ratings");
 
 function cmdModels(filter) {
-  // Scores from benchmark_models.py (3-task: read/count/review, 2026-04-06)
+  // Scores from benchmark_models.py (3-task: read/count/review) + field-tested ledger.
+  // Catalog refreshed 2026-04-19; prior benchmark baseline 2026-04-06.
+  // Since then: native claude `--model opus` alias routes to opus-4.7 1M-ctx (CC extended);
+  //             gpt-5.5 promoted to primary in agent-matrix/model_registry;
+  //             gpt-5.3-codex empirically verified — does heavy internal reasoning
+  //             (66k tokens on trivial "hello" prompt), pick deliberately for architecture.
+  // Billing: native claude/codex/gemini = subscription (marginal $0/call but tokens tracked
+  //          for opportunity cost per operator 2026-04-19). RuAPI / opencode-go = pay-per-use.
   const MODELS = [
-    { name: "Claude Opus 4.6",   tier: "deep",     score: 95, cli: "claude",   flag: "--model opus" },
+    { name: "Claude Opus 4.7 (1M)", tier: "deep", score: 98, cli: "claude",   flag: "--model opus",              tested: true },
+    { name: "Claude Opus 4.7",   tier: "deep",     score: 97, cli: "opencode", flag: "-m RuAPI/claude-opus-4.7",      tested: true },
+    { name: "GPT-5.5",           tier: "deep",     score: 96, cli: "codex",    flag: "-m gpt-5.5",           tested: true },
+    { name: "Claude Opus 4.6",   tier: "deep",     score: 95, cli: "claude",   flag: "--model claude-opus-4-6" },
+    { name: "Opus 4.6 (RuAPI)",  tier: "deep",     score: 95, cli: "opencode", flag: "-m RuAPI/claude-opus-4.6",      tested: true },
     { name: "GPT-5.4-mini",      tier: "fast",     score: 93, cli: "codex",    flag: "-m gpt-5.4-mini",      tested: true },
     { name: "MiniMax M2.7",      tier: "balanced", score: 93, cli: "opencode", flag: "-m opencode-go/minimax-m2.7",   tested: true },
     { name: "Claude Sonnet 4.6", tier: "balanced", score: 90, cli: "claude",   flag: "--model sonnet" },
+    { name: "Sonnet 4.6 (RuAPI)",tier: "balanced", score: 90, cli: "opencode", flag: "-m RuAPI/claude-sonnet-4.6",    tested: true },
     { name: "GPT-5.4",           tier: "balanced", score: 90, cli: "codex",    flag: "-m gpt-5.4",           tested: true },
+    { name: "Gemini 3.1 Pro",    tier: "deep",     score: 89, cli: "opencode", flag: "-m RuAPI/gemini-3.1-pro-preview", tested: true },
     { name: "Kimi K2.5",         tier: "balanced", score: 88, cli: "opencode", flag: "-m opencode-go/kimi-k2.5",      tested: true },
     { name: "Qwen 3.6+ Free",    tier: "free",     score: 88, cli: "opencode", flag: "-m opencode/qwen3.6-plus-free", tested: true },
+    { name: "GPT-5.2",           tier: "balanced", score: 87, cli: "codex",    flag: "-m gpt-5.2",           tested: true },
     { name: "Gemini 3.1 Pro",    tier: "balanced", score: 85, cli: "gemini",   flag: "-m gemini-3.1-pro" },
     { name: "GPT-5.3 Codex",     tier: "deep",     score: 83, cli: "codex",    flag: "-m gpt-5.3-codex",      tested: true },
     { name: "GPT-5.3 Spark",     tier: "fast",     score: 82, cli: "codex",    flag: "-m gpt-5.3-codex-spark" },
@@ -24,7 +38,6 @@ function cmdModels(filter) {
     { name: "Gemini 3 Flash",    tier: "fast",     score: 77, cli: "gemini",   flag: "-m gemini-3-flash" },
     { name: "Mimo v2 Pro",       tier: "fast",     score: 74, cli: "opencode", flag: "-m opencode-go/mimo-v2-pro",    tested: true },
     { name: "GPT-5.4 (opencode)",tier: "fast",     score: 74, cli: "opencode", flag: "-m openai/gpt-5.4",            tested: true },
-    { name: "GPT-5.2",           tier: "balanced", score: 87, cli: "codex",    flag: "-m gpt-5.2",           tested: true },
     { name: "MiniMax M2.5",      tier: "slow",     score: 57, cli: "opencode", flag: "-m opencode-go/minimax-m2.5",   tested: true },
   ];
 
@@ -82,6 +95,17 @@ async function cmdModelsRecommend(target, args) {
   const recScript = findRepoScript(target, "model_router.py");
   if (!recScript) { log("model router unavailable"); return; }
 
+  // Ledger-recommend: pair per-repo outcome ledger (PR #509) with the static
+  // experience-event ranking. Falls back to the legacy `recommend` subcommand
+  // if the installed copy of model_router.py predates ledger-recommend —
+  // happens if an operator upgrades the CLI before the ai/ layer catches up.
+  const ledgerArgs = [recScript, "ledger-recommend", "--target", target];
+  if (taskType) ledgerArgs.push("--task", taskType);
+  if (asJson) ledgerArgs.push("--json");
+
+  const ledgerResult = spawnSync("python3", ledgerArgs, { stdio: "inherit" });
+  if (typeof ledgerResult.status === "number" && ledgerResult.status === 0) return;
+
   const fwd = [recScript, "recommend", "--target", target];
   if (taskType) fwd.push("--task", taskType);
   if (goal) fwd.push("--goal", goal);

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