npm - @erdoai/cli - Versions diffs - 0.5.1 → 0.23.1 - Mend

@erdoai/cli 0.5.1 → 0.23.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +1245 -65
package/package.json +2 -2

package/dist/index.js CHANGED Viewed

@@ -2,6 +2,7 @@
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
 import { select } from "@inquirer/prompts";
 import { Command } from "commander";
@@ -109,26 +110,72 @@ var ErdoApiError = class extends Error {
   }
   status;
 };
+var ErdoNetworkError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ErdoNetworkError";
+  }
+  cause;
+};
+var NETWORK_BACKOFF_MS = [250, 1e3];
+function networkErrorFor(method, path, err) {
+  const cause = err?.cause ?? err;
+  const code = cause?.code;
+  const causeMsg = cause?.message ?? String(cause);
+  const detail = code ? `${code} (${causeMsg})` : causeMsg;
+  return new ErdoNetworkError(`${method} ${path} failed: ${detail}`, cause);
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function rawRequest(baseURL, token, orgId, method, path, body) {
   const headers = { Authorization: `Bearer ${token}` };
   if (orgId) headers["X-Organization-ID"] = orgId;
   if (body !== void 0) headers["Content-Type"] = "application/json";
-  const res = await fetch(`${baseURL}${path}`, {
-    method,
-    headers,
-    body: body !== void 0 ? JSON.stringify(body) : void 0
-  });
-  const text = await res.text();
-  if (!res.ok) {
-    let message = text;
+  const upper = method.toUpperCase();
+  const maxRetries = upper === "GET" || upper === "HEAD" ? 2 : 1;
+  let attempt = 0;
+  while (true) {
+    let res;
     try {
-      const parsed = JSON.parse(text);
-      message = parsed.message || parsed.error || text;
-    } catch {
+      res = await fetch(`${baseURL}${path}`, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    } catch (err) {
+      const netErr = networkErrorFor(method, path, err);
+      if (attempt < maxRetries) {
+        await sleep(NETWORK_BACKOFF_MS[Math.min(attempt, NETWORK_BACKOFF_MS.length - 1)]);
+        attempt++;
+        continue;
+      }
+      throw netErr;
     }
-    throw new ErdoApiError(res.status, message || `${method} ${path} failed (${res.status})`);
+    const text = await res.text();
+    if (!res.ok) {
+      throw new ErdoApiError(res.status, errorMessageFor(method, path, res, text));
+    }
+    return text ? JSON.parse(text) : void 0;
+  }
+}
+function errorMessageFor(method, path, res, text) {
+  try {
+    const parsed = JSON.parse(text);
+    const message = parsed.message || parsed.error;
+    if (message) return message;
+  } catch {
+  }
+  if (looksLikeHTML(text)) {
+    const statusText = res.statusText ? ` ${res.statusText}` : "";
+    return `${method} ${path} was answered by a proxy, not the Erdo API (HTTP ${res.status}${statusText}). The request may still be running server-side.`;
   }
-  return text ? JSON.parse(text) : void 0;
+  const trimmed = text.trim();
+  if (!trimmed) return `${method} ${path} failed (${res.status})`;
+  return trimmed.length > 500 ? `${trimmed.slice(0, 500)}\u2026` : trimmed;
+}
+function looksLikeHTML(text) {
+  const head = text.trimStart().slice(0, 200).toLowerCase();
+  return head.startsWith("<!doctype html") || head.startsWith("<html") || head.includes("<head>");
 }
 function fetchMe(token, orgId) {
   return rawRequest(resolveApiUrl(), token, orgId, "GET", "/v1/me");
@@ -156,6 +203,12 @@ var ErdoClient = class {
   listOrganizations() {
     return this.request("GET", "/v1/organizations");
   }
+  getAutonomyMode() {
+    return this.request("GET", "/v1/autonomy-mode");
+  }
+  setAutonomyMode(mode) {
+    return this.request("PUT", "/v1/autonomy-mode", { mode });
+  }
   listEvalSuites() {
     return this.request("GET", "/v1/evals/suites");
   }
@@ -208,6 +261,172 @@ var ErdoClient = class {
       `/v1/evals/runs/${encodeURIComponent(runID)}`
     );
   }
+  // --- projects ---
+  listProjects(params) {
+    const q = new URLSearchParams();
+    if (params?.limit) q.set("limit", String(params.limit));
+    if (params?.offset) q.set("offset", String(params.offset));
+    const qs = q.toString();
+    return this.request("GET", `/v1/projects${qs ? `?${qs}` : ""}`);
+  }
+  createProject(input) {
+    return this.request("POST", "/v1/projects", input);
+  }
+  // --- workstreams ---
+  listWorkstreams(status) {
+    const q = new URLSearchParams();
+    for (const s of status ?? []) q.append("status", s);
+    const qs = q.toString();
+    return this.request("GET", `/v1/workstreams${qs ? `?${qs}` : ""}`);
+  }
+  getWorkstream(slug) {
+    return this.request("GET", `/v1/workstreams/${encodeURIComponent(slug)}`);
+  }
+  createWorkstream(input) {
+    return this.request("POST", "/v1/workstreams", input);
+  }
+  updateWorkState(slug, input) {
+    return this.request("PATCH", `/v1/workstreams/${encodeURIComponent(slug)}/state`, input);
+  }
+  appendWorkstreamEvent(slug, body) {
+    return this.request(
+      "POST",
+      `/v1/workstreams/${encodeURIComponent(slug)}/events`,
+      { body }
+    );
+  }
+  listWorkstreamEvents(slug, limit) {
+    const qs = limit ? `?limit=${limit}` : "";
+    return this.request(
+      "GET",
+      `/v1/workstreams/${encodeURIComponent(slug)}/events${qs}`
+    );
+  }
+  addWorkstreamPhase(slug, input) {
+    return this.request(
+      "POST",
+      `/v1/workstreams/${encodeURIComponent(slug)}/phases`,
+      input
+    );
+  }
+  armWorkstreamLoop(slug, input) {
+    return this.request("POST", `/v1/workstreams/${encodeURIComponent(slug)}/arm`, input ?? {});
+  }
+  readWorkstreamLedger(slug, observationsPerExperiment) {
+    const qs = observationsPerExperiment ? `?observations_per_experiment=${observationsPerExperiment}` : "";
+    return this.request(
+      "GET",
+      `/v1/workstreams/${encodeURIComponent(slug)}/ledger${qs}`
+    );
+  }
+  attachWorkstreamResource(slug, input) {
+    return this.request(
+      "POST",
+      `/v1/workstreams/${encodeURIComponent(slug)}/resources`,
+      input
+    );
+  }
+  // --- experiments ---
+  listExperiments(params) {
+    const q = new URLSearchParams();
+    if (params?.workstream_slug) q.set("workstream_slug", params.workstream_slug);
+    if (params?.scope) q.set("scope", params.scope);
+    for (const s of params?.status ?? []) q.append("status", s);
+    const qs = q.toString();
+    return this.request("GET", `/v1/experiments${qs ? `?${qs}` : ""}`);
+  }
+  getExperiment(slug) {
+    return this.request("GET", `/v1/experiments/${encodeURIComponent(slug)}`);
+  }
+  getExperimentPolicy(slug) {
+    return this.request(
+      "GET",
+      `/v1/experiments/${encodeURIComponent(slug)}/policy`
+    );
+  }
+  createExperiment(input) {
+    return this.request("POST", "/v1/experiments", input);
+  }
+  updateExperiment(slug, input) {
+    return this.request("PATCH", `/v1/experiments/${encodeURIComponent(slug)}`, input);
+  }
+  runPersonaPanel(slug, input) {
+    return this.request("POST", `/v1/experiments/${encodeURIComponent(slug)}/panel`, input ?? {});
+  }
+  diagnoseExperimentPersonas(slug, input) {
+    return this.request("POST", `/v1/experiments/${encodeURIComponent(slug)}/diagnose`, input ?? {});
+  }
+  groundPersonas(input) {
+    return this.request("POST", "/v1/persona-grounding", input ?? {});
+  }
+  listExperimentObservations(slug, params) {
+    const q = new URLSearchParams();
+    if (params?.variant_key) q.set("variant_key", params.variant_key);
+    if (params?.observation_type) q.set("observation_type", params.observation_type);
+    if (params?.judge_slug) q.set("judge_slug", params.judge_slug);
+    if (params?.limit) q.set("limit", String(params.limit));
+    const qs = q.toString();
+    return this.request(
+      "GET",
+      `/v1/experiments/${encodeURIComponent(slug)}/observations${qs ? `?${qs}` : ""}`
+    );
+  }
+  // The trust dial: each judge's track record from the experiment ledger —
+  // paired predictions and pairwise agreement vs measured reality. The endpoint
+  // scopes by project + a ledger-scan limit; a judge filter is applied client-side
+  // over the returned rows (see the CLI command), the API has no judge parameter.
+  judgeCalibration(params) {
+    const q = new URLSearchParams();
+    if (params?.project_slug) q.set("project_slug", params.project_slug);
+    if (params?.limit) q.set("limit", String(params.limit));
+    const qs = q.toString();
+    return this.request(
+      "GET",
+      `/v1/judge-calibration${qs ? `?${qs}` : ""}`
+    );
+  }
+  listCrossCustomerPriors() {
+    return this.request("GET", "/v1/cross-customer-priors");
+  }
+  recordAllocationDecision(experimentSlug, input) {
+    return this.request(
+      "POST",
+      `/v1/experiments/${encodeURIComponent(experimentSlug)}/allocation-decisions`,
+      input
+    );
+  }
+  // A synchronous long call — the LLM judges every surviving pair, which can take
+  // minutes; the comparisons persist to the experiment ledger.
+  runPairwiseTournament(experimentSlug, input) {
+    return this.request(
+      "POST",
+      `/v1/experiments/${encodeURIComponent(experimentSlug)}/tournament`,
+      input
+    );
+  }
+  // Also synchronous and potentially slow — one prediction is written per variant
+  // page of the judge's kind across the org's live experiments.
+  backtestJudge(judgeSlug) {
+    return this.request("POST", "/v1/judge-backtests", { judge_slug: judgeSlug });
+  }
+  // --- attention ---
+  listAttentionItems(params) {
+    const q = new URLSearchParams();
+    for (const s of params?.statuses ?? []) q.append("statuses", s);
+    if (params?.engine_actions_only) q.set("engine_actions_only", "true");
+    if (params?.limit) q.set("limit", String(params.limit));
+    if (params?.offset) q.set("offset", String(params.offset));
+    const qs = q.toString();
+    return this.request("GET", `/v1/attention${qs ? `?${qs}` : ""}`);
+  }
+  // id may be a UUID or the item's slug — the backend accepts both.
+  respondAttentionItem(id, input) {
+    return this.request(
+      "POST",
+      `/v1/attention/${encodeURIComponent(id)}/respond`,
+      input
+    );
+  }
   // --- agents ---
   ask(input) {
     return this.request("POST", "/v1/ask", input);
@@ -261,6 +480,9 @@ var ErdoClient = class {
   listThreads() {
     return this.request("GET", "/v1/threads");
   }
+  getThreadMessages(threadId) {
+    return this.request("GET", `/v1/threads/${encodeURIComponent(threadId)}/messages`);
+  }
   // --- datasets ---
   listDatasets() {
     return this.request(
@@ -268,12 +490,83 @@ var ErdoClient = class {
       "/v1/datasets"
     );
   }
-  queryDataset(slug, query, timezone) {
+  // The endpoint's field is `question` (QueryDataNaturalLanguageInput). Sending
+  // `query` made every `erdo datasets query` fail with "question is required".
+  queryDataset(slug, question, timezone) {
     return this.request("POST", `/v1/datasets/${encodeURIComponent(slug)}/query-nl`, {
-      query,
+      question,
       timezone
     });
   }
+  uploadDatasetFile(body) {
+    return this.request("POST", "/v1/datasets-upload", body);
+  }
+  createIntegrationDataset(body) {
+    return this.request(
+      "POST",
+      "/v1/integration-datasets",
+      body
+    );
+  }
+  // --- integrations ---
+  discoverIntegrationTables(integration, schemaName) {
+    const qs = schemaName ? `?schema_name=${encodeURIComponent(schemaName)}` : "";
+    return this.request("GET", `/v1/integrations/${encodeURIComponent(integration)}/tables${qs}`);
+  }
+  listIntegrations() {
+    return this.request("GET", "/v1/integrations");
+  }
+  searchIntegrationApps(query) {
+    const qs = query ? `?query=${encodeURIComponent(query)}` : "";
+    return this.request("GET", `/v1/integration-apps${qs}`);
+  }
+  connectIntegration(body) {
+    return this.request("POST", "/v1/integrations-connect", body);
+  }
+  checkIntegrationConnection(app) {
+    return this.request("GET", `/v1/integrations-connect/${encodeURIComponent(app)}`);
+  }
+  // --- dataset filters ---
+  listDatasetFilters(datasetSlug) {
+    return this.request(
+      "GET",
+      `/v1/datasets/${encodeURIComponent(datasetSlug)}/filters`
+    );
+  }
+  createDatasetFilter(datasetSlug, body) {
+    return this.request(
+      "POST",
+      `/v1/datasets/${encodeURIComponent(datasetSlug)}/filters`,
+      body
+    );
+  }
+  deleteDatasetFilter(datasetSlug, filterId) {
+    return this.request(
+      "DELETE",
+      `/v1/datasets/${encodeURIComponent(datasetSlug)}/filters/${encodeURIComponent(filterId)}`
+    );
+  }
+  // --- event pipelines ---
+  listEventPipelines(limit, offset) {
+    const q = new URLSearchParams();
+    if (limit) q.set("limit", String(limit));
+    if (offset) q.set("offset", String(offset));
+    const qs = q.toString();
+    return this.request("GET", `/v1/event-pipelines${qs ? `?${qs}` : ""}`);
+  }
+  getEventPipeline(slug) {
+    return this.request("GET", `/v1/event-pipelines/${encodeURIComponent(slug)}`);
+  }
+  listEventPipelineExecutions(slug, limit, offset) {
+    const q = new URLSearchParams();
+    if (limit) q.set("limit", String(limit));
+    if (offset) q.set("offset", String(offset));
+    const qs = q.toString();
+    return this.request(
+      "GET",
+      `/v1/event-pipelines/${encodeURIComponent(slug)}/executions${qs ? `?${qs}` : ""}`
+    );
+  }
   // --- knowledge ---
   listKnowledge() {
     return this.request("GET", "/v1/knowledge");
@@ -283,6 +576,9 @@ var ErdoClient = class {
     if (limit) params.set("limit", String(limit));
     return this.request("GET", `/v1/knowledge-search?${params.toString()}`);
   }
+  setKnowledgeVisibility(id, visibility) {
+    return this.request("PATCH", `/v1/knowledge/${id}/visibility`, { visibility });
+  }
   // --- automations (heartbeats) ---
   listHeartbeats() {
     return this.request(
@@ -331,6 +627,24 @@ var ErdoClient = class {
   getAgentRun(id) {
     return this.request("GET", `/v1/runs/${encodeURIComponent(id)}`);
   }
+  // --- approvals ---
+  listApprovals(opts) {
+    const params = new URLSearchParams();
+    if (opts.status) params.set("status", opts.status);
+    if (opts.limit) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return this.request(
+      "GET",
+      `/v1/approvals${qs ? `?${qs}` : ""}`
+    );
+  }
+  decideApproval(id, input) {
+    return this.request(
+      "POST",
+      `/v1/approvals/${encodeURIComponent(id)}/decide`,
+      input
+    );
+  }
   // --- pages / artifacts ---
   deployPage(input) {
     return this.request("POST", "/v1/pages", input);
@@ -365,9 +679,10 @@ import { spawn } from "child_process";
 import { randomBytes } from "crypto";
 import { createServer } from "http";
 import { hostname } from "os";
+import * as readline from "readline";
 var REDIRECT_URI = "http://localhost:8080/callback";
 var PORT = 8080;
-var LOGIN_TIMEOUT_MS = 3 * 60 * 1e3;
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
 function openBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
@@ -376,9 +691,56 @@ function openBrowser(url) {
   } catch {
   }
 }
+function copyToClipboard(text) {
+  const b64 = Buffer.from(text, "utf8").toString("base64");
+  let osc = `\x1B]52;c;${b64}\x07`;
+  if (process.env.TMUX) osc = `\x1BPtmux;${osc.replace(/\x1b/g, "\x1B\x1B")}\x1B\\`;
+  process.stdout.write(osc);
+  const cmd = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip";
+  const args = process.platform === "linux" ? ["-selection", "clipboard"] : [];
+  try {
+    const child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+    child.on("error", () => {
+    });
+    child.stdin.end(text);
+    child.unref();
+  } catch {
+  }
+}
+function parsePastedCode(input, state) {
+  const text = input.trim();
+  if (!text) return null;
+  if (text.includes("code=")) {
+    let params;
+    try {
+      params = new URL(text).searchParams;
+    } catch {
+      params = new URLSearchParams(text.replace(/^[^?]*\?/, ""));
+    }
+    const code = params.get("code");
+    if (!code) return { error: "that looks like a callback URL but has no code parameter" };
+    const gotState = params.get("state");
+    if (!gotState || gotState !== state) return { error: "state mismatch \u2014 copy the URL from THIS login attempt's tab" };
+    return { code };
+  }
+  if (/^[A-Za-z0-9_-]{20,}$/.test(text)) return { code: text };
+  return { error: "couldn't find an authorization code in that \u2014 paste the full localhost callback URL" };
+}
 function waitForCode(state) {
   return new Promise((resolve, reject) => {
-    const server = createServer((req, res) => {
+    let settled = false;
+    let server;
+    let rl;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      server?.close();
+      if (rl) rl.close();
+      if (process.stdin.isTTY) process.stdin.setRawMode?.(false);
+      process.stdin.pause();
+      fn();
+    };
+    server = createServer((req, res) => {
       const u = new URL(req.url || "", REDIRECT_URI);
       if (u.pathname !== "/callback") {
         res.writeHead(404);
@@ -391,16 +753,17 @@ function waitForCode(state) {
       res.end(
         '<html><head><meta charset="utf-8"></head><body><h2>Erdo CLI \u2014 authenticated. You can close this tab.</h2></body></html>'
       );
-      server.close();
-      if (gotState !== state) return reject(new Error("state mismatch \u2014 login aborted"));
-      if (!code) return reject(new Error("no authorization code returned"));
-      resolve(code);
+      if (gotState !== state) return finish(() => reject(new Error("state mismatch \u2014 login aborted")));
+      if (!code) return finish(() => reject(new Error("no authorization code returned")));
+      finish(() => resolve(code));
     });
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        reject(new Error(`port ${PORT} is in use \u2014 free it and retry (or use 'erdo login --key')`));
+        finish(
+          () => reject(new Error(`port ${PORT} is in use \u2014 free it and retry (or use 'erdo login --key')`))
+        );
       } else {
-        reject(err);
+        finish(() => reject(err));
       }
     });
     server.listen(PORT, () => {
@@ -409,12 +772,58 @@ function waitForCode(state) {
       const authURL = `${api}/auth/cli?response_type=code&client_id=erdo-cli&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&state=${state}&token_name=${encodeURIComponent(tokenName)}`;
       console.log(`Opening your browser to authorize\u2026
 If it doesn't open, visit:
-  ${authURL}`);
+  ${authURL}
+`);
+      if (process.stdin.isTTY) {
+        console.log(
+          "Working over ssh? Press c to copy the URL to your local clipboard, open it\nin your local browser, then paste the localhost callback URL (from the tab\nthat fails to load) here and press Enter."
+        );
+      }
       openBrowser(authURL);
+      if (process.stdin.isTTY) {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode?.(true);
+        process.stdin.resume();
+        let buffer = "";
+        process.stdin.on("keypress", (str, key) => {
+          if (settled) return;
+          if (key?.ctrl && key.name === "c") {
+            finish(() => reject(new Error("login cancelled")));
+            return;
+          }
+          if (key?.name === "return" || key?.name === "enter") {
+            const parsed = parsePastedCode(buffer, state);
+            buffer = "";
+            process.stdout.write("\n");
+            if (!parsed) return;
+            if ("error" in parsed) {
+              console.log(`  \u2717 ${parsed.error}`);
+              return;
+            }
+            finish(() => resolve(parsed.code));
+            return;
+          }
+          if (key?.name === "backspace") {
+            if (buffer.length > 0) {
+              buffer = buffer.slice(0, -1);
+              process.stdout.write("\b \b");
+            }
+            return;
+          }
+          if ((str === "c" || str === "C") && buffer.length === 0) {
+            copyToClipboard(authURL);
+            console.log("  \u2713 copied the login URL to your clipboard");
+            return;
+          }
+          if (str && !key?.ctrl && !key?.meta) {
+            buffer += str;
+            process.stdout.write(str);
+          }
+        });
+      }
     });
     setTimeout(() => {
-      server.close();
-      reject(new Error("login timed out after 3 minutes"));
+      finish(() => reject(new Error("login timed out after 5 minutes")));
     }, LOGIN_TIMEOUT_MS).unref();
   });
 }
@@ -508,10 +917,29 @@ function fail(err) {
   }
   process.exit(1);
 }
+function awaitingApprovalMessage(threadID) {
+  return [
+    "the run paused for approval.",
+    "  erdo approvals list --status pending",
+    "  erdo approvals decide <id> --approve",
+    `  erdo agent messages ${threadID}`
+  ].join("\n");
+}
+function timedOutMessage(threadID) {
+  return [
+    "timed out waiting for the run to finish \u2014 it is still running on its thread.",
+    `  erdo agent messages ${threadID}`,
+    `  erdo runs list --thread ${threadID}`
+  ].join("\n");
+}
 function print(value) {
   console.log(JSON.stringify(value, null, 2));
 }
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var collect = (v, acc) => {
+  acc.push(v);
+  return acc;
+};
 function summariseResults(results, cases = []) {
   const nameByID = new Map(cases.map((c) => [c.id, c.name]));
   for (const r of results) {
@@ -669,6 +1097,20 @@ org.command("use [idOrSlug]").description("Set the active org for the current ac
     fail(e);
   }
 });
+org.command("autonomy [mode]").description("Show or set the org's engine-autonomy mode (autopilot | propose | strict)").action(async (mode) => {
+  try {
+    const api = new ErdoClient();
+    if (mode) {
+      const { mode: updated } = await api.setAutonomyMode(mode);
+      console.log(`Autonomy mode set to: ${updated}`);
+    } else {
+      const { mode: current } = await api.getAutonomyMode();
+      console.log(`Autonomy mode: ${current}`);
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
 var evalCmd = program.command("eval").description("Run and manage evals");
 evalCmd.command("suites").description("List eval suites in the active org (+ global)").action(async () => {
   try {
@@ -687,6 +1129,475 @@ evalCmd.command("suite <slug>").description("Show a suite and its cases").action
     fail(e);
   }
 });
+var projectCmd = program.command("project").description("Projects \u2014 the container workstreams and experiments live in");
+projectCmd.command("list").description("List projects in the active org").option("-n, --limit <n>", "max projects", (v) => parseInt(v, 10)).option("--offset <n>", "pagination offset", (v) => parseInt(v, 10)).action(async (opts) => {
+  try {
+    print(await new ErdoClient().listProjects({ limit: opts.limit, offset: opts.offset }));
+  } catch (e) {
+    fail(e);
+  }
+});
+projectCmd.command("create").description("Create a project in the active org").requiredOption("--slug <slug>", "URL-safe slug, unique per org").requiredOption("--name <name>", "human-readable name").option("--description <text>", "free-form description").action(async (opts) => {
+  try {
+    print(
+      await new ErdoClient().createProject({
+        slug: opts.slug,
+        name: opts.name,
+        description: opts.description
+      })
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+var wsCmd = program.command("workstream").description("Drive and observe Workstreams");
+wsCmd.command("list").description("List workstreams in the active org").option("-s, --status <status...>", "filter by status (active, awaiting_user, blocked, completed)").action(async (opts) => {
+  try {
+    print(await new ErdoClient().listWorkstreams(opts.status));
+  } catch (e) {
+    fail(e);
+  }
+});
+wsCmd.command("get <slug>").description("Show a workstream \u2014 status, phases, resources, recent log").action(async (slug) => {
+  try {
+    print(await new ErdoClient().getWorkstream(slug));
+  } catch (e) {
+    fail(e);
+  }
+});
+wsCmd.command("create").description("Create a workstream in a project").requiredOption("--project <slug>", "project slug").requiredOption("--slug <slug>", "workstream slug (unique per org)").requiredOption("--title <title>", "human-readable title").option("--description <text>", "free-form description").action(async (opts) => {
+  try {
+    print(
+      await new ErdoClient().createWorkstream({
+        project_slug: opts.project,
+        slug: opts.slug,
+        title: opts.title,
+        description: opts.description
+      })
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+wsCmd.command("log <slug> <body...>").description("Append a line to the workstream's event log").action(async (slug, body) => {
+  try {
+    print(await new ErdoClient().appendWorkstreamEvent(slug, body.join(" ")));
+  } catch (e) {
+    fail(e);
+  }
+});
+wsCmd.command("events <slug>").description("Show a workstream's full event log (newest first)").option("-n, --limit <n>", "max events", (v) => parseInt(v, 10)).action(async (slug, opts) => {
+  try {
+    print(await new ErdoClient().listWorkstreamEvents(slug, opts.limit));
+  } catch (e) {
+    fail(e);
+  }
+});
+wsCmd.command("phase-add <slug>").description("Append a new phase to a workstream").requiredOption("--phase-slug <phaseSlug>", "URL-safe phase id, unique within the workstream").requiredOption("--title <title>", "human-readable phase title").option("--skill <skillSlug>", "optional skill that runs this phase").action(
+  async (slug, opts) => {
+    try {
+      print(
+        await new ErdoClient().addWorkstreamPhase(slug, {
+          slug: opts.phaseSlug,
+          title: opts.title,
+          skill_slug: opts.skill
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+wsCmd.command("set-state <slug>").description("Update a workstream's status / title / description").option("--status <status>", "active, awaiting_user, blocked, completed").option("--title <title>", "retitle").option("--description <text>", "describe current state / surface a blocker").option("--summary <text>", "one-line audit-log summary of this update").action(
+  async (slug, opts) => {
+    try {
+      print(
+        await new ErdoClient().updateWorkState(slug, {
+          status: opts.status,
+          title: opts.title,
+          description: opts.description,
+          summary: opts.summary
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+wsCmd.command("arm <slug>").description("Arm the recurring reconciliation loop (allocator pass) for a workstream").option("--interval <minutes>", "how often the loop runs", (v) => parseInt(v, 10)).option("--model <id>", "model the loop runs on").option("--timezone <tz>", "timezone for scheduling").option("--token-budget <millicents>", "total spend ceiling in millicents (tenths of a cent)", (v) => parseInt(v, 10)).option("--escalation-budget <n>", "max escalations to a human per day", (v) => parseInt(v, 10)).action(
+  async (slug, opts) => {
+    try {
+      const client = new ErdoClient();
+      if (opts.tokenBudget !== void 0 || opts.escalationBudget !== void 0) {
+        await client.updateWorkState(slug, {
+          token_budget_millicents: opts.tokenBudget,
+          escalation_budget_per_day: opts.escalationBudget
+        });
+      }
+      print(
+        await client.armWorkstreamLoop(slug, {
+          interval_minutes: opts.interval,
+          model: opts.model,
+          timezone: opts.timezone
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+wsCmd.command("ledger <slug>").description(
+  "Read the allocator's single ledger view \u2014 budget, experiments + observations, judge calibration, attention items, allocator recommendation"
+).option("--observations <n>", "observations to include per experiment", (v) => parseInt(v, 10)).action(async (slug, opts) => {
+  try {
+    print(await new ErdoClient().readWorkstreamLedger(slug, opts.observations));
+  } catch (e) {
+    fail(e);
+  }
+});
+wsCmd.command("attach <slug>").description("Link a resource (page, dataset, heartbeat, experiment_run, \u2026) to a workstream").requiredOption("--type <resourceType>", "resource type (page, dataset, heartbeat, experiment_run, \u2026)").requiredOption("--id <resourceId>", "the resource's UUID").requiredOption("--rel <relationshipType>", "output | input | evidence | monitoring | subject | parent | child | running").option("--title <title>", "optional label for the link").option("--phase <phaseId>", "optional phase to attach under").action(
+  async (slug, opts) => {
+    try {
+      print(
+        await new ErdoClient().attachWorkstreamResource(slug, {
+          resource_type: opts.type,
+          resource_id: opts.id,
+          relationship_type: opts.rel,
+          title: opts.title,
+          phase_id: opts.phase
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+function parseVariant(spec) {
+  const v = {};
+  for (const raw of spec.split(",")) {
+    const part = raw.trim();
+    if (!part) continue;
+    const eq = part.indexOf("=");
+    if (eq === -1) {
+      if (part === "control" || part === "is_control") {
+        v.is_control = true;
+        continue;
+      }
+      throw new Error(`--variant: unknown flag "${part}" (expected key=, label=, page=, alloc=, class=, or 'control')`);
+    }
+    const k = part.slice(0, eq).trim();
+    const val = part.slice(eq + 1).trim();
+    switch (k) {
+      case "key":
+        v.key = val;
+        break;
+      case "label":
+        v.label = val;
+        break;
+      case "alloc":
+      case "allocation_percent":
+        v.allocation_percent = parseInt(val, 10);
+        if (isNaN(v.allocation_percent)) throw new Error(`--variant alloc= must be an integer, got: ${val}`);
+        break;
+      case "control":
+      case "is_control":
+        v.is_control = val !== "false";
+        break;
+      case "page":
+        v.treatment_resource_type = "page";
+        v.treatment_resource_id = val;
+        break;
+      case "type":
+      case "treatment_resource_type":
+        v.treatment_resource_type = val;
+        break;
+      case "resource":
+      case "treatment_resource_id":
+        v.treatment_resource_id = val;
+        break;
+      case "class":
+      case "treatment_class":
+        v.treatment_class = val;
+        break;
+      default:
+        throw new Error(`--variant: unknown key "${k}"`);
+    }
+  }
+  if (!v.key) {
+    throw new Error('--variant requires key=, e.g. --variant "key=control,label=Current,control"');
+  }
+  if (!v.label) v.label = v.key;
+  return v;
+}
+function parseEvidence(spec) {
+  const s = spec.trim();
+  if (!s.includes("=")) {
+    const idx = s.lastIndexOf(":");
+    const slug2 = idx === -1 ? s : s.slice(0, idx);
+    const role2 = idx === -1 ? "primary" : s.slice(idx + 1);
+    if (!slug2.trim()) throw new Error("--evidence requires a dataset slug");
+    return { dataset_slug: slug2.trim(), role: (role2 || "primary").trim() };
+  }
+  let slug = "";
+  let role = "primary";
+  for (const raw of s.split(",")) {
+    const part = raw.trim();
+    if (!part) continue;
+    const eq = part.indexOf("=");
+    if (eq === -1) throw new Error(`--evidence: expected key=value pair, got "${part}"`);
+    const k = part.slice(0, eq).trim();
+    const val = part.slice(eq + 1).trim();
+    if (k === "slug" || k === "dataset" || k === "dataset_slug") slug = val;
+    else if (k === "role") role = val;
+    else throw new Error(`--evidence: unknown key "${k}"`);
+  }
+  if (!slug) throw new Error('--evidence requires slug=, e.g. --evidence "slug=my-leads,role=primary"');
+  return { dataset_slug: slug, role };
+}
+var expCmd = program.command("experiment").description("Drive and observe Experiments");
+expCmd.command("list").description("List experiment runs").option("-w, --workstream <slug>", "filter to one workstream").option("--scope <scope>", "local, platform_canary, platform_global").option("-s, --status <status...>", "filter by status (planned, running, reading, decided)").action(async (opts) => {
+  try {
+    print(
+      await new ErdoClient().listExperiments({
+        workstream_slug: opts.workstream,
+        scope: opts.scope,
+        status: opts.status
+      })
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+expCmd.command("get <slug>").description("Show an experiment \u2014 hypothesis, variants, evidence, status, decision").action(async (slug) => {
+  try {
+    print(await new ErdoClient().getExperiment(slug));
+  } catch (e) {
+    fail(e);
+  }
+});
+expCmd.command("policy <slug>").description(
+  "Show the decision policy state \u2014 per-variant posteriors, allocation, win frequencies, stop probabilities, calibration gate, recommended decision, and HAIPW effect readout"
+).action(async (slug) => {
+  try {
+    print(await new ErdoClient().getExperimentPolicy(slug));
+  } catch (e) {
+    fail(e);
+  }
+});
+expCmd.command("create").description("Create an experiment with its variants, evidence datasets and decision rule").requiredOption("--project <slug>", "project slug").requiredOption("--slug <slug>", "experiment slug (unique per org)").requiredOption("--title <title>", "title").option("--workstream <slug>", "host workstream").option("--scope <scope>", "local (default), platform_canary, platform_global").option("--hypothesis <text>", "hypothesis markdown").option("--primary-metric <metric>", "the metric the decision rule reads").option("--decision-rule <text>", "the rule that decides ship/stop from the primary metric").option("--guardrail <metric>", "a metric that must not regress (repeatable)", collect, []).option(
+  "--variant <spec>",
+  'a variant "key=b,label=3-field form,page=<artifact-id>,alloc=50,class=form_length_change,control" (repeatable). Fields: key=, label=, page=, alloc=, class=, and the bare flag control (or control=true) to mark the baseline. class= declares the structural change vs control for cross-experiment learning: headline_change | hero_media_change | cta_change | form_length_change | social_proof_add | layout_reorder | offer_change | full_page_rebuild',
+  collect,
+  []
+).option(
+  "--evidence <spec>",
+  'a measurement dataset "slug=<dataset>,role=primary" or "<dataset-slug>:<role>" (repeatable)',
+  collect,
+  []
+).action(
+  async (opts) => {
+    try {
+      const variants = opts.variant.map(parseVariant);
+      const evidence_datasets = opts.evidence.map(parseEvidence);
+      print(
+        await new ErdoClient().createExperiment({
+          project_slug: opts.project,
+          slug: opts.slug,
+          title: opts.title,
+          workstream_slug: opts.workstream,
+          scope: opts.scope,
+          hypothesis_markdown: opts.hypothesis,
+          primary_metric: opts.primaryMetric,
+          decision_rule_markdown: opts.decisionRule,
+          guardrail_metrics: opts.guardrail.length ? opts.guardrail : void 0,
+          variants: variants.length ? variants : void 0,
+          evidence_datasets: evidence_datasets.length ? evidence_datasets : void 0
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+expCmd.command("observations <slug>").description("Read an experiment's observation log (metric reads / decisions / actions / judge forecasts)").option("--variant <key>", "filter to one variant").option("--type <type>", "metric_read, decision_check, action, prediction, comparison").option("--judge <slug>", "filter to one judge's forecasts within this experiment").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10)).action(
+  async (slug, opts) => {
+    try {
+      print(
+        await new ErdoClient().listExperimentObservations(slug, {
+          variant_key: opts.variant,
+          observation_type: opts.type,
+          judge_slug: opts.judge,
+          limit: opts.limit
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+expCmd.command("priors").description(
+  "List the platform's cross-customer prior library \u2014 the aggregate effect of each treatment class (headline_change, cta_change, \u2026) on each page metric, pooled across all contributing orgs. Aggregate-only (\u22655 experiments, \u22653 orgs per cell); nothing identifies any org, page, or result."
+).action(async () => {
+  try {
+    print(await new ErdoClient().listCrossCustomerPriors());
+  } catch (e) {
+    fail(e);
+  }
+});
+expCmd.command("panel <slug>").description("Run the persona panel (wind tunnel): brand-brief personas predict each page variant's micro-conversions before paid traffic decides").option("--persona <slug...>", "restrict to these persona skill slugs (default: every approved persona)").option("--variant <key...>", "restrict to these variant keys (default: every page variant)").option("--draws <n>", "K samples per persona\xD7variant averaged into the prediction (default 5)", (v) => parseInt(v, 10)).option("--wait", "poll until the panel's ranking (decision_check) lands, then print it").action(
+  async (slug, opts) => {
+    try {
+      const client = new ErdoClient();
+      const started = await client.runPersonaPanel(slug, {
+        persona_slugs: opts.persona,
+        variant_keys: opts.variant,
+        draws: opts.draws
+      });
+      print(started);
+      if (!opts.wait) return;
+      const deadline = Date.now() + 20 * 60 * 1e3;
+      process.stderr.write("waiting for the panel ranking");
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 5e3));
+        process.stderr.write(".");
+        const res = await client.listExperimentObservations(slug, {
+          observation_type: "decision_check",
+          limit: 20
+        });
+        for (const obs of res.observations ?? []) {
+          const details = typeof obs.details === "string" ? JSON.parse(obs.details) : obs.details;
+          if (details && details.panel_run_id === started.panel_run_id) {
+            process.stderr.write("\n");
+            print({ ranking: details.ranking, kill_list: details.kill_list ?? [], primary_metric: details.primary_metric, failed_cells: details.failed_cells ?? [] });
+            return;
+          }
+        }
+      }
+      process.stderr.write("\n");
+      fail(new Error(`panel still running after 20m \u2014 check later with: erdo experiment observations ${slug} --type decision_check`));
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+expCmd.command("diagnose <slug>").description(
+  "Run wind-tunnel Stage B: browser sessions diagnose WHERE and WHY each persona bails on the surviving variants (never estimates \u2014 run the panel first for the ranking)"
+).option("--top-k <n>", "how many surviving variants get sessions (default 3)", (v) => parseInt(v, 10)).option("--survivor <key...>", "survival ranking, best first (default: the latest panel's decision_check ranking)").option("--persona <slug...>", "restrict to these persona skill slugs").action(
+  async (slug, opts) => {
+    try {
+      const ack = await new ErdoClient().diagnoseExperimentPersonas(slug, {
+        top_k: opts.topK,
+        survivor_variant_keys: opts.survivor,
+        persona_slugs: opts.persona
+      });
+      print(ack);
+      process.stderr.write(
+        `sessions run in the background; read the narratives with: erdo experiment observations ${slug} --type action_taken
+`
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+expCmd.command("decide <slug>").description("Record an experiment's decision (ship/stop/iterate/inconclusive)").requiredOption("--decision <decision>", "ship, stop, iterate, inconclusive").option("--outcome <text>", "the narrative result").action(async (slug, opts) => {
+  try {
+    print(
+      await new ErdoClient().updateExperiment(slug, {
+        status: "decided",
+        decision: opts.decision,
+        outcome_markdown: opts.outcome
+      })
+    );
+  } catch (e) {
+    fail(e);
+  }
+});
+expCmd.command("set-status <slug> <status>").description("Set an experiment's status (planned, running, reading, decided)").action(async (slug, status) => {
+  try {
+    print(await new ErdoClient().updateExperiment(slug, { status }));
+  } catch (e) {
+    fail(e);
+  }
+});
+expCmd.command("calibration").description(
+  "Read each judge's track record \u2014 paired predictions and pairwise agreement vs measured reality (the trust dial)"
+).option("--project <slug>", "limit to one project (default: every project you can view)").option("--judge <slug>", "show only judges whose slug contains this text").option("-n, --limit <n>", "max ledger rows scanned (default 5000)", (v) => parseInt(v, 10)).action(async (opts) => {
+  try {
+    const res = await new ErdoClient().judgeCalibration({
+      project_slug: opts.project,
+      limit: opts.limit
+    });
+    if (opts.judge && Array.isArray(res.judges)) {
+      const needle = opts.judge.toLowerCase();
+      res.judges = res.judges.filter((j) => j.judge_slug.toLowerCase().includes(needle));
+    }
+    print(res);
+  } catch (e) {
+    fail(e);
+  }
+});
+expCmd.command("record-decision <slug>").description(
+  "Record that you are overriding the allocator's recommendation for one bet (calibration data on the allocator)"
+).requiredOption("--variant <key>", "the variant/bet you are deciding on").requiredOption(
+  "--recommended <action>",
+  "what the allocator recommended: fund | hold | kill_candidate | lottery_slot | champion_trial"
+).requiredOption("--chosen <action>", "the action you chose instead").requiredOption("--reason <text>", "why you overrode the recommendation").action(
+  async (slug, opts) => {
+    try {
+      print(
+        await new ErdoClient().recordAllocationDecision(slug, {
+          variant_key: opts.variant,
+          recommended_action: opts.recommended,
+          chosen_action: opts.chosen,
+          reason: opts.reason
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+expCmd.command("tournament <slug>").description(
+  "Coalesce an experiment's variants: cluster near-dups, judge survivors pairwise, fit a Bradley\u2013Terry ranking; comparisons persist to the ledger"
+).requiredOption("--criteria <text>", "the criteria the judge ranks pairs on").option("--kind <kind>", "restrict to variants of this artifact kind").option("--variant <key>", "restrict to these variant keys (repeatable)", collect, []).option("--max-comparisons <n>", "cap on pairwise comparisons", (v) => parseInt(v, 10)).action(
+  async (slug, opts) => {
+    try {
+      process.stderr.write("judging pairs \u2014 this can take a few minutes\u2026\n");
+      print(
+        await new ErdoClient().runPairwiseTournament(slug, {
+          criteria: opts.criteria,
+          kind: opts.kind,
+          variant_keys: opts.variant.length ? opts.variant : void 0,
+          max_comparisons: opts.maxComparisons
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+var judgeCmd = program.command("judge").description("Judges \u2014 back-tests and calibration");
+judgeCmd.command("backtest <judgeSlug>").description(
+  "Run a judge over the org's live experiments' variant pages of its kind and persist one prediction per variant (earns calibration standing immediately; idempotent \u2014 already-forecast variants are skipped)"
+).action(async (judgeSlug) => {
+  try {
+    process.stderr.write("back-testing \u2014 this can take a few minutes\u2026\n");
+    print(await new ErdoClient().backtestJudge(judgeSlug));
+  } catch (e) {
+    fail(e);
+  }
+});
+var personaCmd = program.command("persona").description("Ground personas in measured traffic");
+personaCmd.command("ground").description(
+  "Ground the org's persona skills in measured behavior: cluster the last 28 days of page-events sessions and update each matching persona in place (silent no-op below the data gates)"
+).option("--window-days <n>", "look-back window in days (default 28)", (v) => parseInt(v, 10)).action(async (opts) => {
+  try {
+    print(await new ErdoClient().groundPersonas({ window_days: opts.windowDays }));
+  } catch (e) {
+    fail(e);
+  }
+});
 function parseRubric(json) {
   try {
     return JSON.parse(json);
@@ -694,10 +1605,6 @@ function parseRubric(json) {
     throw new Error(`--rubric must be valid JSON, e.g. '[{"criterion":"brand","weight":1}]'`);
   }
 }
-var collect = (v, acc) => {
-  acc.push(v);
-  return acc;
-};
 function caseScoringPayload(opts) {
   const out = {};
   if (opts.rubric) out.rubric = parseRubric(opts.rubric);
@@ -765,7 +1672,7 @@ evalCmd.command("run <slug>").description("Run a suite; --watch polls until it c
     console.log(`run_id: ${run_id}`);
     if (!opts.watch) return;
     for (; ; ) {
-      await sleep(5e3);
+      await sleep2(5e3);
       const { run, results, cases } = await api.getEvalRun(run_id);
       if (run.status === "running") {
         console.log(`  ...running (${results.length}/${run.total_cases} cases scored)`);
@@ -861,33 +1768,32 @@ caseCmd.command("rm <slug> <caseName>").description("Archive a case from a suite
 });
 var agentCmd = program.command("agent").description("Run agents");
 agentCmd.command("ask <question>").description("Ask the data-question agent (one-shot); prints the answer").option("-d, --datasets <csv>", "dataset slugs to scope to").option(
-  "--async",
-  "kick off the run and poll for the result instead of holding one long request open (use for slow builds)"
+  "--sync",
+  "hold one long HTTP request open until the run finishes, instead of polling. Faster for quick questions; a proxy will time it out on any run over ~100s, losing the thread id while the run continues server-side"
 ).action(async (question, opts) => {
   try {
     const client = new ErdoClient();
     const res = await client.ask({
       question,
       dataset_slugs: opts.datasets ? opts.datasets.split(",").map((s) => s.trim()) : void 0,
-      async: opts.async
+      async: !opts.sync
     });
-    if (opts.async) {
-      process.stderr.write(`thread: ${res.thread_id}
-running\u2026`);
-      const run = await client.waitForThreadRun(res.thread_id, {
-        onTick: () => process.stderr.write(".")
-      });
-      process.stderr.write("\n");
-      if (!run) throw new Error("timed out waiting for the run to finish");
-      if (run.status === "awaiting_approval")
-        throw new Error("run needs approval \u2014 approve it in the Erdo app, then re-check the thread");
-      if (run.error) throw new Error(run.error);
-      console.log(run.output || `(status: ${run.status})`);
+    if (opts.sync) {
+      console.log(res.answer || `(status: ${res.status})`);
       console.log(`
 thread: ${res.thread_id}`);
       return;
     }
-    console.log(res.answer || `(status: ${res.status})`);
+    process.stderr.write(`thread: ${res.thread_id}
+running\u2026`);
+    const run = await client.waitForThreadRun(res.thread_id, {
+      onTick: () => process.stderr.write(".")
+    });
+    process.stderr.write("\n");
+    if (!run) throw new Error(timedOutMessage(res.thread_id));
+    if (run.status === "awaiting_approval") throw new Error(awaitingApprovalMessage(res.thread_id));
+    if (run.error) throw new Error(run.error);
+    console.log(run.output || `(status: ${run.status})`);
     console.log(`
 thread: ${res.thread_id}`);
   } catch (e) {
@@ -895,33 +1801,32 @@ thread: ${res.thread_id}`);
   }
 });
 agentCmd.command("send <threadId> <message>").description("Send a message to a thread and print the agent's reply").option("-a, --agent <key>", "agent to invoke (e.g. erdo.artifact-builder)").option(
-  "--async",
-  "kick off the run and poll for the result instead of holding one long request open (use for slow builds)"
+  "--sync",
+  "hold one long HTTP request open until the run finishes, instead of polling. Faster for quick questions; a proxy will time it out on any run over ~100s while the run continues server-side"
 ).action(async (threadId, message, opts) => {
   try {
     const client = new ErdoClient();
-    const baselineRunID = opts.async ? await client.latestRunID(threadId) : void 0;
+    const baselineRunID = opts.sync ? void 0 : await client.latestRunID(threadId);
     const res = await client.sendMessage(threadId, {
       message,
       agent_key: opts.agent,
-      async: opts.async
+      async: !opts.sync
     });
     if (res.error) throw new Error(res.error);
-    if (opts.async) {
-      process.stderr.write("running\u2026");
-      const run = await client.waitForThreadRun(threadId, {
-        ignoreRunID: baselineRunID,
-        onTick: () => process.stderr.write(".")
-      });
-      process.stderr.write("\n");
-      if (!run) throw new Error("timed out waiting for the run to finish");
-      if (run.status === "awaiting_approval")
-        throw new Error("run needs approval \u2014 approve it in the Erdo app, then re-check the thread");
-      if (run.error) throw new Error(run.error);
-      console.log(run.output || `(status: ${run.status})`);
+    if (opts.sync) {
+      console.log(res.answer || `(status: ${res.status})`);
       return;
     }
-    console.log(res.answer || `(status: ${res.status})`);
+    process.stderr.write("running\u2026");
+    const run = await client.waitForThreadRun(threadId, {
+      ignoreRunID: baselineRunID,
+      onTick: () => process.stderr.write(".")
+    });
+    process.stderr.write("\n");
+    if (!run) throw new Error(timedOutMessage(threadId));
+    if (run.status === "awaiting_approval") throw new Error(awaitingApprovalMessage(threadId));
+    if (run.error) throw new Error(run.error);
+    console.log(run.output || `(status: ${run.status})`);
   } catch (e) {
     fail(e);
   }
@@ -945,6 +1850,24 @@ agentCmd.command("threads").description("List your threads").action(async () =>
     fail(e);
   }
 });
+agentCmd.command("messages <threadId>").description("Show a thread's messages (role + text)").action(async (threadId) => {
+  try {
+    const { messages } = await new ErdoClient().getThreadMessages(threadId);
+    for (const m of messages) {
+      const role = m.message.author_entity_type === "app" ? "agent" : m.message.author_entity_type;
+      console.log(`\u2014 ${role} \xB7 ${m.message.created_at} \u2014`);
+      for (const c of m.contents) {
+        if (c.content_type === "text") {
+          console.log(c.content);
+        } else {
+          console.log(`\x1B[2m[${c.content_type}]\x1B[0m`);
+        }
+      }
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
 var runsCmd = program.command("runs").description("Inspect agent runs");
 runsCmd.command("list").description("List agent runs (filter by agent OR thread \u2014 mutually exclusive)").option("-a, --agent <key>", "filter by agent key").option("-t, --thread <id>", "filter to a thread").option("-l, --limit <n>", "max runs", (v) => parseInt(v, 10)).action(async (opts) => {
   try {
@@ -961,6 +1884,88 @@ runsCmd.command("get <id>").description("Show an agent run (status, output, trac
     fail(e);
   }
 });
+var approvalsCmd = program.command("approvals").description("List and decide approval requests (actions agents paused on)");
+approvalsCmd.command("list").description("List approval requests, optionally filtered by status").option("-s, --status <status>", "pending | approved | rejected | expired (default: all)").option("-l, --limit <n>", "max requests", (v) => parseInt(v, 10)).option("--json", "output raw JSON").action(async (opts) => {
+  try {
+    const res = await new ErdoClient().listApprovals(opts);
+    if (opts.json) {
+      print(res);
+      return;
+    }
+    for (const r of res.requests) {
+      console.log(
+        `${r.id}	${r.status}	${r.action_key}	${r.action_display}	${r.created_at}`
+      );
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
+approvalsCmd.command("decide <id>").description("Approve or reject a pending approval request").option("--approve", "approve the request").option("--reject", "reject the request").option(
+  "--scope <scope>",
+  "once (default) | always_this_job | always_org | always_user",
+  "once"
+).action(async (id, opts) => {
+  try {
+    if (opts.approve === opts.reject) {
+      throw new Error("specify exactly one of --approve or --reject");
+    }
+    const res = await new ErdoClient().decideApproval(id, {
+      decision: opts.approve ? "approved" : "rejected",
+      scope: opts.scope
+    });
+    console.log(res.message);
+  } catch (e) {
+    fail(e);
+  }
+});
+var attnCmd = program.command("attention").description("The attention feed \u2014 digests, choices, escalations awaiting a human");
+attnCmd.command("list").description("List attention items").option("--status <status...>", "open | answered | dismissed | expired").option("--open", "shorthand for --status open").option("--engine-actions", "only engine-generated items").option("-n, --limit <n>", "max items", (v) => parseInt(v, 10)).option("--offset <n>", "pagination offset", (v) => parseInt(v, 10)).action(
+  async (opts) => {
+    try {
+      const statuses = opts.status?.length ? opts.status : opts.open ? ["open"] : void 0;
+      print(
+        await new ErdoClient().listAttentionItems({
+          statuses,
+          engine_actions_only: opts.engineActions,
+          limit: opts.limit,
+          offset: opts.offset
+        })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  }
+);
+attnCmd.command("respond <id>").description(
+  `Respond to an attention item. A choice answer's shape is {"<question_id>": ["<option>", ...]}. Answering a choice mapped to experiment variants records your pick as a human comparison in the calibration ledger.`
+).option("--answer <json>", `a JSON answer, e.g. '{"q1":["option-a"]}'`).option("--ack", "mark read / acknowledge").option("--dismiss", "dismiss the item").action(async (id, opts) => {
+  try {
+    const given = [opts.answer !== void 0, !!opts.ack, !!opts.dismiss].filter(Boolean).length;
+    if (given !== 1) {
+      fail(new Error("provide exactly one of --answer, --ack, or --dismiss"));
+    }
+    let input;
+    if (opts.answer !== void 0) {
+      let parsed;
+      try {
+        parsed = JSON.parse(opts.answer);
+      } catch {
+        throw new Error(
+          `--answer must be valid JSON, e.g. '{"<question_id>": ["<option>", ...]}'`
+        );
+      }
+      input = { action: "answer", answer: parsed };
+    } else if (opts.ack) {
+      input = { action: "acknowledge" };
+    } else {
+      input = { action: "dismiss" };
+    }
+    print(await new ErdoClient().respondAttentionItem(id, input));
+  } catch (e) {
+    fail(e);
+  }
+});
 var pagesCmd = program.command("pages").description("Create and manage pages/artifacts");
 function readMaybeFile(v) {
   if (!v) return void 0;
@@ -1066,6 +2071,172 @@ datasetsCmd.command("query <slug> <question>").description("Ask a natural-langua
     fail(e);
   }
 });
+var MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
+datasetsCmd.command("upload <file>").description("Upload a file (CSV, Excel, JSON, ...) and create a dataset from it").option("-n, --name <name>", "display name for the dataset (defaults to the filename)").option("-d, --description <text>", "description shown to agents analyzing the dataset").action(async (file, opts) => {
+  try {
+    const content = readFileSync2(file);
+    if (content.byteLength > MAX_UPLOAD_BYTES) {
+      fail(
+        new Error(
+          `${file} is ${Math.round(content.byteLength / (1024 * 1024))} MB \u2014 the upload limit is 20 MB; upload larger files through the Erdo web app`
+        )
+      );
+    }
+    const filename = basename(file);
+    const res = await new ErdoClient().uploadDatasetFile({
+      filename,
+      content_base64: content.toString("base64"),
+      name: opts.name,
+      description: opts.description
+    });
+    console.log(`Created dataset ${res.slug} (${res.dataset_id})`);
+    if (res.ready === false) {
+      console.log(`Warning: ${res.warning ?? "the file's schema could not be extracted; it is not yet queryable."}`);
+    } else {
+      console.log(`Query it with: erdo datasets query ${res.slug} "..."`);
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
+datasetsCmd.command("from-integration <app>").description("Create a dataset backed by a connected database integration (live-queryable, no copy)").requiredOption("-n, --name <name>", "display name for the dataset").option("-s, --schemas <csv>", "schema names to include (see: erdo integrations tables <app>)").option("-d, --description <text>", "description shown to agents analyzing the dataset").action(async (app, opts) => {
+  try {
+    const res = await new ErdoClient().createIntegrationDataset({
+      integration: app,
+      name: opts.name,
+      description: opts.description,
+      schemas: opts.schemas ? opts.schemas.split(",").map((s) => s.trim()) : void 0
+    });
+    console.log(`Created dataset ${res.slug} (${res.dataset_id}), status: ${res.status}`);
+    console.log(`Table discovery runs in the background \u2014 query shortly with: erdo datasets query ${res.slug} "..."`);
+  } catch (e) {
+    fail(e);
+  }
+});
+var OPERATORS = ["equals", "not_equals", "greater_than", "less_than", "contains", "between"];
+function parseCondition(s) {
+  const m = s.trim().match(/^(\S+)\s+(\S+)\s+([\s\S]+)$/);
+  if (!m) {
+    fail(new Error(`invalid --where ${JSON.stringify(s)}; expected '<column> <operator> <value>', e.g. 'email contains @example.com'`));
+  }
+  const [, column, operator, value] = m;
+  if (!OPERATORS.includes(operator)) {
+    fail(new Error(`unsupported operator ${JSON.stringify(operator)}; allowed: ${OPERATORS.join(", ")}`));
+  }
+  return { column, operator, value };
+}
+var filterCmd = datasetsCmd.command("filter").description("Manage a dataset's default filters");
+filterCmd.command("list <slug>").description("List the default filters on a dataset").action(async (slug) => {
+  try {
+    print(await new ErdoClient().listDatasetFilters(slug));
+  } catch (e) {
+    fail(e);
+  }
+});
+var integrationsCmd = program.command("integrations").description("Connect and inspect integrations");
+integrationsCmd.command("list").description("List connected integrations").action(async () => {
+  try {
+    const { integrations } = await new ErdoClient().listIntegrations();
+    for (const i of integrations) console.log(`${i.app}	${i.status}	${i.auth_type}	${i.name}`);
+  } catch (e) {
+    fail(e);
+  }
+});
+integrationsCmd.command("apps [query]").description("Search connectable apps (native integrations + SaaS apps)").action(async (query) => {
+  try {
+    const { apps } = await new ErdoClient().searchIntegrationApps(query);
+    for (const a of apps) console.log(`${a.app}	${a.source}	${a.auth_types.join(",")}	${a.name}`);
+  } catch (e) {
+    fail(e);
+  }
+});
+integrationsCmd.command("connect <app>").description("Connect an app \u2014 pass credentials with -c, or get a browser connect URL for OAuth apps").option("-c, --credential <key=value...>", "credential field (repeatable)", (v, acc) => acc.concat(v), []).option("-n, --name <name>", "display name for the connection").action(async (app, opts) => {
+  try {
+    let credentials;
+    if (opts.credential.length) {
+      credentials = {};
+      for (const c of opts.credential) {
+        const eq = c.indexOf("=");
+        if (eq < 1) fail(new Error(`invalid --credential ${JSON.stringify(c)}; expected key=value`));
+        credentials[c.slice(0, eq)] = c.slice(eq + 1);
+      }
+    }
+    const res = await new ErdoClient().connectIntegration({ app, name: opts.name, credentials });
+    print(res);
+    if (res.connect_url) {
+      console.error(`
+Open this URL in a browser to authorize, then run: erdo integrations status ${app}`);
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
+integrationsCmd.command("status <app>").description("Check whether an app is connected (completes browser-authorized connections)").action(async (app) => {
+  try {
+    print(await new ErdoClient().checkIntegrationConnection(app));
+  } catch (e) {
+    fail(e);
+  }
+});
+integrationsCmd.command("tables <app> [schema]").description("List a connected database integration's schemas, or a schema's tables with columns").action(async (app, schema) => {
+  try {
+    const res = await new ErdoClient().discoverIntegrationTables(app, schema);
+    if (!schema) {
+      for (const s of res.schemas) console.log(`${s.name}	${s.type}`);
+      if (res.schemas.length) console.log(`
+List tables with: erdo integrations tables ${app} <schema>`);
+      return;
+    }
+    for (const t of res.tables ?? []) {
+      const rows = t.estimated_row_count != null ? `	~${t.estimated_row_count} rows` : "";
+      console.log(`${t.schema_name}.${t.table_name}	${t.columns.length} columns${rows}`);
+    }
+  } catch (e) {
+    fail(e);
+  }
+});
+var pipelinesCmd = program.command("event-pipelines").description("Inspect event pipelines (lead-capture / webhook flows)");
+pipelinesCmd.command("list").description("List event pipelines in the active org").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10)).action(async (opts) => {
+  try {
+    print(await new ErdoClient().listEventPipelines(opts.limit));
+  } catch (e) {
+    fail(e);
+  }
+});
+pipelinesCmd.command("get <slug>").description("Show one event pipeline \u2014 state, source, endpoint URL, actions, write targets").action(async (slug) => {
+  try {
+    print(await new ErdoClient().getEventPipeline(slug));
+  } catch (e) {
+    fail(e);
+  }
+});
+filterCmd.command("add <slug>").description("Add a default filter to a dataset").requiredOption(
+  "--where <condition>",
+  "a '<column> <operator> <value>' condition (repeatable, AND-combined), e.g. --where 'email contains @example.com'. Operators: " + OPERATORS.join(", ") + " (for 'between' use 'col between 10,100')",
+  collect,
+  []
+).option("--name <name>", "optional human-readable label, e.g. 'Exclude test submissions'").action(async (slug, opts) => {
+  try {
+    const conditions = opts.where.map(parseCondition);
+    print(await new ErdoClient().createDatasetFilter(slug, { name: opts.name, conditions }));
+  } catch (e) {
+    fail(e);
+  }
+});
+filterCmd.command("remove <slug> <filterId>").description("Remove a filter from a dataset (use 'filter list' to find the id). Hides nothing further; never deletes data.").action(async (slug, filterId) => {
+  try {
+    print(await new ErdoClient().deleteDatasetFilter(slug, filterId));
+  } catch (e) {
+    fail(e);
+  }
+});
+pipelinesCmd.command("executions <slug>").description("Show an event pipeline's recent run history (newest first)").option("-n, --limit <n>", "max executions", (v) => parseInt(v, 10)).action(async (slug, opts) => {
+  try {
+    print(await new ErdoClient().listEventPipelineExecutions(slug, opts.limit));
+  } catch (e) {
+    fail(e);
+  }
+});
 var knowledgeCmd = program.command("knowledge").description("Knowledge objects");
 knowledgeCmd.command("list").description("List knowledge objects").action(async () => {
   try {
@@ -1081,6 +2252,15 @@ knowledgeCmd.command("search <query>").description("Semantic search over knowled
     fail(e);
   }
 });
+knowledgeCmd.command("visibility <id> <visibility>").description(
+  "Set a knowledge object's visibility: 'workspace' (organization-internal) or 'public' (answerable by external surfaces like the website voice widget once approved)"
+).action(async (id, visibility) => {
+  try {
+    print(await new ErdoClient().setKnowledgeVisibility(id, visibility));
+  } catch (e) {
+    fail(e);
+  }
+});
 var autoCmd = program.command("automations").description("Scheduled automations (heartbeats)");
 autoCmd.command("list").description("List automations").action(async () => {
   try {