@wayai/cli 0.3.135 → 0.3.137

package/dist/index.js

@@ -236,7 +236,7 @@ var init_mask_secrets = __esm({
     "use strict";
     CREDENTIAL_KEY_RE = /token|secret|credential|password|passwd|api[_-]?key|authorization|private[_-]?key|session[_-]?id|cookie|jwt/i;
     NUMERIC_CREDENTIAL_KEY_RE = /(?:password|passwd|pin|token|secret|credential|api[_-]?key|authorization|private[_-]?key|session[_-]?id|cookie|jwt)$/i;
-    FULLY_MASKED_VALUE_RE = /^(?:(?:Bearer|Basic)\s+)?(?:way_|wst_)?\[REDACTED(?:_JWT|_BASE64)?\]$/;
+    FULLY_MASKED_VALUE_RE = /^(?:(?:Bearer|Basic)\s+)?(?:way_|wst_|rec_)?\[REDACTED(?:_JWT|_BASE64)?\]$/;
     isCredentialKey = (key) => CREDENTIAL_KEY_RE.test(key);
     isBase64UrlChar = (char) => {
       const code = char.charCodeAt(0);
@@ -249,6 +249,12 @@ var init_mask_secrets = __esm({
       [/\bway_[A-Za-z0-9_-]{8,}/g, "way_[REDACTED]"],
       // wst_ single-use WebSocket tickets (same opaque base64url format).
       [/\bwst_[A-Za-z0-9_-]{8,}/g, "wst_[REDACTED]"],
+      // rec_ Data-surface API tokens. Same opaque base64url shape, and needed for
+      // the same reason as way_: the credential-KEY rules below only fire when the
+      // token sits behind a recognisable key, so a `rec_` token that appears bare in
+      // an error body's prose would otherwise pass through unmasked. Unpadded
+      // base64url, so the trailing base64 rule does not cover it either.
+      [/\brec_[A-Za-z0-9_-]{8,}/g, "rec_[REDACTED]"],
       // Stripe API keys and webhook signing secrets. Keep this aligned with
       // packages/core/src/redact.ts; both modules protect observability sinks.
       [
@@ -7546,6 +7552,20 @@ var init_contracts = __esm({
       production_bases: external_exports.boolean(),
       /** Opaque to Rekor; compared for equality only, to reset `usage:` counters (§2.3). */
       window_key: external_exports.string().min(1),
+      /**
+       * The window's TRUE lower bound, for the reconcile's `operations_log` sum (§2.2).
+       *
+       * OPTIONAL, and that is not a rollout convenience — it is what "never gates" means
+       * on the writer's side. The tier sources can be absent (a paid row carrying
+       * `current_period_end` with no `current_period_start`) and inverted pairs are a
+       * §2.2 diagnostic, so requiring it here would let an inert field throw the strict
+       * parse and leave the org with NO projection — permanently stale under §2.3, with
+       * §2.5's fail-closed gates refusing base creation and 503-ing every import. The
+       * writer emits it whenever it has a sound value and omits it otherwise; Rekor's
+       * observed-flip fallback covers the gap, and rollout step 3 keeps that fallback
+       * for exactly this reason.
+       */
+      window_start: external_exports.string().datetime().optional(),
       /** The sole staleness authority (§2.3). Never triggers a counter reset. */
       window_resets_at: external_exports.string().datetime()
     }).strict();
@@ -8700,7 +8720,8 @@ __export(api_client_exports, {
   ApiClient: () => ApiClient,
   ApiError: () => ApiError,
   dataErrorMessage: () => dataErrorMessage,
-  toDataProxyPath: () => toDataProxyPath
+  toDataProxyPath: () => toDataProxyPath,
+  withOrgSelector: () => withOrgSelector
 });
 function isRetryableErrorBody(body) {
   try {
@@ -8716,6 +8737,11 @@ function toDataProxyPath(v1Path) {
   }
   return `${DATA_PROXY_PREFIX}${v1Path.slice(REKOR_V1_PREFIX.length)}`;
 }
+function withOrgSelector(path31, orgId) {
+  if (!orgId) return path31;
+  const separator = path31.includes("?") ? "&" : "?";
+  return `${path31}${separator}${DATA_PROXY_ORG_QUERY_PARAM}=${encodeURIComponent(orgId)}`;
+}
 function dataErrorMessage(err) {
   if (!(err instanceof ApiError)) return null;
   let parsed;
@@ -9328,12 +9354,12 @@ var init_api_client = __esm({
           `/api/admin/data-explorer/debug/observability/${encodeURIComponent(hubId)}/conversations/${encodeURIComponent(conversationId)}${qs}`
         );
       }
-      async request(method, path31, body) {
+      async request(method, path31, body, extraHeaders, contentType) {
         addApiBreadcrumb(method, path31);
         const url = `${this.apiUrl}${path31}`;
         let refreshedOn401 = false;
         for (let retry = 0; ; retry++) {
-          let response = await this.send(url, method, body);
+          let response = await this.send(url, method, body, extraHeaders, contentType);
           if (response.status === 401 && this.onUnauthorized && !refreshedOn401) {
             refreshedOn401 = true;
             let refreshed;
@@ -9343,7 +9369,7 @@ var init_api_client = __esm({
             }
             if (refreshed) {
               this.accessToken = refreshed;
-              response = await this.send(url, method, body);
+              response = await this.send(url, method, body, extraHeaders, contentType);
             }
           }
           if (response.ok) {
@@ -9384,30 +9410,98 @@ var init_api_client = __esm({
        * since it is WayAI's selector and not an input Rekor sees.
        */
       async dataRequest(method, v1Path, body, orgId) {
-        const separator = v1Path.includes("?") ? "&" : "?";
-        const orgQuery = orgId ? `${separator}${DATA_PROXY_ORG_QUERY_PARAM}=${encodeURIComponent(orgId)}` : "";
         const envelope = await this.request(
           method,
-          `${toDataProxyPath(v1Path)}${orgQuery}`,
+          withOrgSelector(toDataProxyPath(v1Path), orgId),
           body
         );
         return envelope ?? {};
       }
+      /**
+       * Upload raw bytes to a Data `/v1` path — file content and record
+       * attachments, the two places that surface takes a body which is not JSON.
+       * `extraHeaders` carries the surface's own metadata headers, which are
+       * caller-supplied and so cannot displace the org selector or anything `send`
+       * pins.
+       */
+      async dataUpload(v1Path, bytes, contentType, orgId, extraHeaders) {
+        const envelope = await this.request(
+          "PUT",
+          withOrgSelector(toDataProxyPath(v1Path), orgId),
+          bytes,
+          extraHeaders,
+          // NOT a header on the map above: `send` pins the content type out of
+          // caller reach, and takes it here so it always describes the real body.
+          contentType
+        );
+        return envelope ?? {};
+      }
+      /**
+       * Download a Data `/v1` path's raw bytes. Distinct from `dataRequest`, which
+       * parses the JSON envelope: the response here is the stored blob itself, so
+       * this reads `arrayBuffer()`. Single-refresh-on-401 like `request`, but no
+       * transient-retry loop — re-streaming a blob is not worth a cold-start probe.
+       */
+      async dataDownload(v1Path, orgId) {
+        const path31 = withOrgSelector(toDataProxyPath(v1Path), orgId);
+        addApiBreadcrumb("GET", path31);
+        const url = `${this.apiUrl}${path31}`;
+        let response = await this.send(url, "GET");
+        if (response.status === 401 && this.onUnauthorized) {
+          let refreshed;
+          try {
+            refreshed = await this.onUnauthorized();
+          } catch {
+          }
+          if (refreshed) {
+            this.accessToken = refreshed;
+            response = await this.send(url, "GET");
+          }
+        }
+        if (!response.ok) {
+          throw new ApiError("GET", path31, response.status, await response.text());
+        }
+        return {
+          bytes: new Uint8Array(await response.arrayBuffer()),
+          contentType: response.headers.get("Content-Type") ?? "application/octet-stream"
+        };
+      }
+      /**
+       * The absolute URL of a Data `/v1` path, for handing the user a link they can
+       * fetch themselves. Only the address — every request the CLI issues goes
+       * through the methods above, which carry the session.
+       */
+      dataUrl(v1Path, orgId) {
+        return `${this.apiUrl}${withOrgSelector(toDataProxyPath(v1Path), orgId)}`;
+      }
       /** Issue a single authenticated request with the client's current token. */
-      send(url, method, body) {
+      send(url, method, body, extraHeaders, contentType) {
         return fetch(url, {
           method,
           headers: {
+            // Caller-supplied FIRST, so everything pinned below is out of their
+            // reach: a metadata header cannot restate the credential or mislabel
+            // the body.
+            ...extraHeaders,
             Authorization: `Bearer ${this.accessToken}`,
-            "Content-Type": "application/json",
-            // Names the calling process, on every request. A HINT, not an
+            // The content type describes THIS body, so it is derived from the body
+            // rather than accepted from `extraHeaders` — which is pinned out above,
+            // and would otherwise be the one way to mislabel a JSON request.
+            // `||`, not `??`: an empty content type is not a content type, and an
+            // unlabelled body should fall back rather than announce nothing.
+            "Content-Type": body instanceof Uint8Array ? contentType || "application/octet-stream" : "application/json",
+            // Names the calling surface for the Data Worker's audit rows, which
+            // record `cli` vs `api` vs `mcp` (contracts §1.4). A HINT, not an
             // authorization input: any client can send it, so the backend must
             // normalize it against what it knows about its own ingress rather than
             // trust it. Nothing is granted or denied on its value; the Data Worker's
             // audit rows are its consumer (contracts §1.4).
             "X-WayAI-Client": "cli"
           },
-          body: body ? JSON.stringify(body) : void 0
+          // Bytes go on the wire verbatim (file content, attachments); everything
+          // else is JSON. Encoding a Uint8Array through JSON.stringify would send
+          // `{"0":137,…}` — a corrupt upload rather than a failed one.
+          body: !body ? void 0 : body instanceof Uint8Array ? body : JSON.stringify(body)
         });
       }
     };
@@ -12849,6 +12943,20 @@ var init_dist = __esm({
       production_bases: external_exports.boolean(),
       /** Opaque to Rekor; compared for equality only, to reset `usage:` counters (§2.3). */
       window_key: external_exports.string().min(1),
+      /**
+       * The window's TRUE lower bound, for the reconcile's `operations_log` sum (§2.2).
+       *
+       * OPTIONAL, and that is not a rollout convenience — it is what "never gates" means
+       * on the writer's side. The tier sources can be absent (a paid row carrying
+       * `current_period_end` with no `current_period_start`) and inverted pairs are a
+       * §2.2 diagnostic, so requiring it here would let an inert field throw the strict
+       * parse and leave the org with NO projection — permanently stale under §2.3, with
+       * §2.5's fail-closed gates refusing base creation and 503-ing every import. The
+       * writer emits it whenever it has a sound value and omits it otherwise; Rekor's
+       * observed-flip fallback covers the gap, and rollout step 3 keeps that fallback
+       * for exactly this reason.
+       */
+      window_start: external_exports.string().datetime().optional(),
       /** The sole staleness authority (§2.3). Never triggers a counter reset. */
       window_resets_at: external_exports.string().datetime()
     }).strict();
@@ -13979,6 +14087,18 @@ var init_dist = __esm({
   }
 });
 
+// src/lib/expected.ts
+function expected(message) {
+  const err = new Error(message);
+  err.isExpected = true;
+  return err;
+}
+var init_expected = __esm({
+  "src/lib/expected.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/layout.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -14700,11 +14820,31 @@ function isNewerVersion(latest, current) {
   }
   return false;
 }
+function resolveSecretSource(source) {
+  if (source.stdin && source.prompt) {
+    throw expected(`${source.stdinFlag} and ${source.promptHint} are mutually exclusive \u2014 pass one.`);
+  }
+  if (source.stdin) {
+    if (process.stdin.isTTY) {
+      throw expected(
+        `${source.stdinFlag} needs piped input. Pipe it \u2014 printf %s "$SECRET" | wayai \u2026 ${source.stdinFlag} \u2014 or ${source.promptHint}.`
+      );
+    }
+    return "stdin";
+  }
+  if (!process.stdin.isTTY) {
+    throw expected(
+      `A secret cannot be prompted for when stdin is not a terminal. Pipe it instead: printf %s "$SECRET" | wayai \u2026 ${source.stdinFlag}`
+    );
+  }
+  return "prompt";
+}
 var UUID_RE2, slugify, OWN_HELP_COMMANDS;
 var init_utils = __esm({
   "src/lib/utils.ts"() {
     "use strict";
     init_dist();
+    init_expected();
     UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     slugify = slugifySkillName;
     OWN_HELP_COMMANDS = /* @__PURE__ */ new Set([
@@ -14789,7 +14929,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "records",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity. No WayAI command of this name."
       },
       {
@@ -14797,7 +14937,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "record-types",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14805,7 +14945,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "relationships",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14813,7 +14953,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "relationship-types",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14821,7 +14961,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "query-relationships",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology traversal over relationships."
       },
       {
@@ -14829,7 +14969,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "files",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Unambiguous: WayAI has no `files` command \u2014 hub-local resource files are reached through hub config-as-code, and the two file surfaces stay deliberately separate."
       },
       {
@@ -14837,7 +14977,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "file-types",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14845,7 +14985,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "attachments",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14853,7 +14993,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "toolsets",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14861,7 +15001,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "actions",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14869,7 +15009,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "triggers",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14877,7 +15017,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "inbound-webhooks",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity."
       },
       {
@@ -14885,7 +15025,7 @@ var init_registry = __esm({
         disposition: "top-level",
         surviving: "seed",
         clause: 2,
-        shipped: false,
+        shipped: true,
         reason: "Ontology entity. `wayai status` vs `wayai seed lease status` differ by depth, not by word."
       },
       // --- Clause 3: namespaced. ---
@@ -14918,7 +15058,7 @@ var init_registry = __esm({
         disposition: "namespaced",
         surviving: "bases tokens",
         clause: 3,
-        shipped: false,
+        shipped: true,
         reason: "Mints base tokens; WayAI's own token surface mints platform tokens."
       },
       {
@@ -14926,7 +15066,7 @@ var init_registry = __esm({
         disposition: "namespaced",
         surviving: "bases secrets",
         clause: 3,
-        shipped: false,
+        shipped: true,
         reason: "Base org vault; WayAI has connection credentials."
       },
       {
@@ -14934,7 +15074,7 @@ var init_registry = __esm({
         disposition: "namespaced",
         surviving: "bases sql",
         clause: 3,
-        shipped: false,
+        shipped: true,
         reason: "WayAI already has tenant SQL over conversation analytics."
       },
       {
@@ -14942,7 +15082,7 @@ var init_registry = __esm({
         disposition: "namespaced",
         surviving: "bases import",
         clause: 3,
-        shipped: false,
+        shipped: true,
         reason: "WayAI has outbound-contact import."
       },
       {
@@ -14950,7 +15090,7 @@ var init_registry = __esm({
         disposition: "namespaced",
         surviving: "bases batch",
         clause: 3,
-        shipped: false,
+        shipped: true,
         reason: "Too generic to stand alone."
       },
       {
@@ -14958,7 +15098,7 @@ var init_registry = __esm({
         disposition: "namespaced",
         surviving: "bases providers",
         clause: 3,
-        shipped: false,
+        shipped: true,
         reason: "WayAI's provider is a connector."
       },
       {
@@ -14967,14 +15107,14 @@ var init_registry = __esm({
         surviving: "admin bases",
         clause: 3,
         shipped: false,
-        reason: "Clause 3's group exception: `wayai admin` is an existing group with its own gating and subgroups, so the operator surface joins it as a peer rather than sitting under `bases`."
+        reason: "Clause 3's group exception: `wayai admin` is an existing group with its own gating and subgroups, so the operator surface joins it as a peer rather than sitting under `bases`. UNSHIPPED pending a transport: the Data backend's operator routes live at `/admin/*`, a SIBLING of `/v1/*`, and the merged CLI reaches Data only through WayAI's `/api/data` proxy, which contains every forwarded path under `/v1` by construction (`rekor/upstream-url.ts`). The standalone CLI could call them because it held a second `api_url` pointed straight at the Data backend \u2014 the thing the merge deliberately removed. Shipping needs a proxy channel for operator routes plus platform-admin gating on it, which is a backend change, not a CLI one."
       },
       {
         original: "report",
         disposition: "namespaced",
         surviving: "bases report",
         clause: 3,
-        shipped: false,
+        shipped: true,
         reason: "Two report queues still exist, so the merged CLI must be able to file to either. The two collapse when the queues do."
       },
       // --- Neither: one verb each, routing by workspace subtree. ---
@@ -15457,18 +15597,6 @@ var init_token_store = __esm({
   }
 });
 
-// src/lib/expected.ts
-function expected(message) {
-  const err = new Error(message);
-  err.isExpected = true;
-  return err;
-}
-var init_expected = __esm({
-  "src/lib/expected.ts"() {
-    "use strict";
-  }
-});
-
 // src/lib/auth.ts
 var auth_exports = {};
 __export(auth_exports, {
@@ -16746,15 +16874,15 @@ function scanResourceFiles(dir, prefix = "") {
       files.push(...scanResourceFiles(path12.join(dir, entry.name), relPath));
     } else if (entry.isFile()) {
       const fullPath = path12.join(dir, entry.name);
-      const stat = fs10.statSync(fullPath);
-      if (stat.size > MAX_RESOURCE_FILE_SIZE3) {
-        console.warn(`  Warning: skipping ${relPath} (${(stat.size / 1024 / 1024).toFixed(1)}MB exceeds 10MB limit)`);
+      const stat2 = fs10.statSync(fullPath);
+      if (stat2.size > MAX_RESOURCE_FILE_SIZE3) {
+        console.warn(`  Warning: skipping ${relPath} (${(stat2.size / 1024 / 1024).toFixed(1)}MB exceeds 10MB limit)`);
         continue;
       }
       const fileEntry = {
         path: relPath,
         mime_type: guessMimeType(entry.name),
-        file_size: stat.size
+        file_size: stat2.size
       };
       const data = fs10.readFileSync(fullPath);
       fileEntry.hash = computeHash(data);
@@ -16946,34 +17074,34 @@ function resolveTurnAttachments(hubFolder, turn, label, bytesByHash) {
     if (abs !== root && !abs.startsWith(root + path13.sep)) {
       throw expected(`${label}: attachment "${entry}" escapes the hub folder.`);
     }
-    let stat;
+    let stat2;
     try {
-      stat = fs11.statSync(abs);
+      stat2 = fs11.statSync(abs);
     } catch {
     }
-    if (!stat?.isFile()) {
+    if (!stat2?.isFile()) {
       throw expected(`${label}: attachment "${entry}" not found.`);
     }
     if (!realpathContained(root, abs)) {
       throw expected(`${label}: attachment "${entry}" resolves outside the hub folder (symlinks are not allowed).`);
     }
-    if (stat.size > MAX_RESOURCE_FILE_SIZE3) {
+    if (stat2.size > MAX_RESOURCE_FILE_SIZE3) {
       throw expected(
-        `${label}: attachment "${entry}" is ${(stat.size / 1024 / 1024).toFixed(1)}MB, over the 10MB limit.`
+        `${label}: attachment "${entry}" is ${(stat2.size / 1024 / 1024).toFixed(1)}MB, over the 10MB limit.`
       );
     }
     const data = fs11.readFileSync(abs);
     const hash = computeHash(data);
     const fileName = path13.basename(abs);
     const mimeType = guessMimeType(fileName) ?? "application/octet-stream";
-    refs.push({ hash, file_name: fileName, mime_type: mimeType, file_size: stat.size });
+    refs.push({ hash, file_name: fileName, mime_type: mimeType, file_size: stat2.size });
     if (!bytesByHash.has(hash)) {
       bytesByHash.set(hash, {
         hash,
         content_base64: data.toString("base64"),
         file_name: fileName,
         mime_type: mimeType,
-        file_size: stat.size
+        file_size: stat2.size
       });
     }
   }
@@ -17011,7 +17139,7 @@ function rewriteEvalAttachmentsToLocalPaths(payload) {
     return base === "" || base === "." || base === ".." ? ref.hash.slice(0, 16) : base;
   };
   const hashesByName = /* @__PURE__ */ new Map();
-  const collect = (turn) => {
+  const collect2 = (turn) => {
     if (!Array.isArray(turn.attachments)) return;
     for (const ref of turn.attachments) {
       if (!ref?.hash || !ref.file_name) continue;
@@ -17024,7 +17152,7 @@ function rewriteEvalAttachmentsToLocalPaths(payload) {
       set.add(ref.hash);
     }
   };
-  forEachAttachableTurn(payload, collect);
+  forEachAttachableTurn(payload, collect2);
   const pathByKey = /* @__PURE__ */ new Map();
   const usedLower = /* @__PURE__ */ new Set();
   const localPathFor = (ref) => {
@@ -19274,18 +19402,18 @@ __export(send_message_exports, {
 import * as fs19 from "fs";
 import * as path25 from "path";
 function statAttachment(filePath) {
-  let stat;
+  let stat2;
   try {
-    stat = fs19.statSync(filePath);
+    stat2 = fs19.statSync(filePath);
   } catch {
     console.error(`Error: file not found: ${filePath}`);
     process.exit(1);
   }
-  if (stat.isDirectory()) {
+  if (stat2.isDirectory()) {
     console.error(`Error: not a file: ${filePath}`);
     process.exit(1);
   }
-  return { filePath, size: stat.size };
+  return { filePath, size: stat2.size };
 }
 function readAttachment(filePath, size) {
   const fileName = path25.basename(filePath);
@@ -20552,7 +20680,7 @@ async function stopEvalSessionWithRetries(stop, opts = {}) {
   const attempts = opts.attempts ?? STOP_ATTEMPTS;
   const attemptTimeoutMs = opts.attemptTimeoutMs ?? STOP_ATTEMPT_TIMEOUT_MS;
   const backoffMs = opts.backoffMs ?? STOP_BACKOFF_MS;
-  const sleep2 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   let lastError = new Error("Stop was never attempted");
   for (let attempt = 1; attempt <= attempts; attempt++) {
     let timeout;
@@ -20573,7 +20701,7 @@ async function stopEvalSessionWithRetries(stop, opts = {}) {
       if (timeout !== void 0) clearTimeout(timeout);
     }
     const delay2 = backoffMs[attempt - 1];
-    if (attempt < attempts && delay2) await sleep2(delay2);
+    if (attempt < attempts && delay2) await sleep3(delay2);
   }
   throw lastError;
 }
@@ -22512,11 +22640,19 @@ async function updateCredentialCommand(args2) {
   const body = {};
   if (wantsSecret) {
     let input;
-    if (parsed.stdin) {
-      if (process.stdin.isTTY) {
-        console.error("--stdin requires piped input. Use --secret for an interactive masked prompt.");
-        process.exit(1);
-      }
+    let secretSource;
+    try {
+      secretSource = resolveSecretSource({
+        stdin: parsed.stdin,
+        prompt: parsed.secretPrompt,
+        stdinFlag: "--stdin",
+        promptHint: "use --secret for an interactive masked prompt"
+      });
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+    if (secretSource === "stdin") {
       input = await readStdin();
     } else if (authType === "basic_auth") {
       const username = await prompt("Enter username: ");
@@ -24851,8 +24987,8 @@ async function createDataClient(orgId) {
   }
   const org = selected ?? readRepoConfig()?.organization_id;
   return {
-    async request(method, v1Path, body) {
-      const envelope = await api.dataRequest(method, v1Path, body, org);
+    async request(method, path31, body) {
+      const envelope = await api.dataRequest(method, path31, body, org);
       return envelope.data;
     },
     async collectPages(makePath) {
@@ -24868,9 +25004,36 @@ async function createDataClient(orgId) {
         seen.add(cursor);
       }
       return all;
+    },
+    async upload(v1Path, bytes, contentType, headers) {
+      const envelope = await api.dataUpload(v1Path, bytes, contentType, org, headers);
+      return envelope.data;
+    },
+    download(v1Path) {
+      return api.dataDownload(v1Path, org);
+    },
+    url(v1Path) {
+      return api.dataUrl(v1Path, org);
     }
   };
 }
+function dataErrorEnvelope(err) {
+  if (!(err instanceof ApiError)) return null;
+  try {
+    const parsed = JSON.parse(err.body);
+    return parsed?.error ?? null;
+  } catch {
+    return null;
+  }
+}
+function dataErrorCode(err) {
+  const code = dataErrorEnvelope(err)?.code;
+  return typeof code === "string" && code ? code : null;
+}
+function dataErrorDetails(err) {
+  const details = dataErrorEnvelope(err)?.details;
+  return details && typeof details === "object" ? details : void 0;
+}
 var MAX_PAGES;
 var init_client = __esm({
   "src/data/client.ts"() {
@@ -24940,6 +25103,36 @@ function printFields(obj) {
     console.log(`${key.padEnd(width)}  ${formatCell2(value)}`);
   }
 }
+function printBatchResult(response) {
+  const obj = response && typeof response === "object" ? response : {};
+  const results = Array.isArray(obj.results) ? obj.results : [];
+  const batchId = typeof obj.batch_id === "string" ? obj.batch_id : "(none)";
+  console.log(
+    `batch_id: ${sanitizeTerminalText(batchId)} \xB7 ${results.length} operation${results.length === 1 ? "" : "s"}`
+  );
+  if (results.length === 0) return;
+  printRows(
+    results.map((r, i) => ({
+      "#": String(i),
+      operation: r?.type ?? "",
+      result: summarizeBatchResult(r)
+    }))
+  );
+}
+function summarizeBatchResult(r) {
+  if (!r || typeof r !== "object") return String(r ?? "");
+  if (r.deleted === true) return "deleted";
+  const entity = r.record ?? r.relationship ?? r.record_type;
+  if (entity && typeof entity === "object") {
+    const e = entity;
+    const id = typeof e.id === "string" ? e.id : void 0;
+    const label = typeof e.record_type === "string" ? e.record_type : typeof e.rel_type === "string" ? e.rel_type : typeof e.name === "string" ? e.name : void 0;
+    const version = e.version != null ? ` v${String(e.version)}` : "";
+    if (id && label) return `${label}/${id}${version}`;
+    if (id) return `${id}${version}`;
+  }
+  return JSON.stringify(r);
+}
 function cellAt(row, column) {
   return formatCell2(row?.[column]);
 }
@@ -24977,313 +25170,2672 @@ function pathSegment(id, label = "id") {
   }
   return encodeURIComponent(id);
 }
-function parseData(data) {
-  if (data.startsWith("@")) {
-    return JSON.parse(readFileSync19(data.slice(1), "utf-8"));
+function foreignSegment(value, label = "id") {
+  if (value === "." || value === "..") {
+    throw expected(`Invalid ${label}: ${JSON.stringify(value)} is a path traversal segment.`);
+  }
+  return encodeURIComponent(value);
+}
+function pathSegments(value, label = "path") {
+  return value.split("/").map((segment) => foreignSegment(segment, label)).join("/");
+}
+function parseData(data, flag) {
+  const prefix = flag ? `${flag}: ` : "";
+  const source = data.startsWith("@") ? data.slice(1) : void 0;
+  let text = data;
+  if (source !== void 0) {
+    try {
+      text = readFileSync19(source, "utf-8");
+    } catch (e) {
+      throw expected(`${prefix}${source}: ${e instanceof Error ? e.message : "could not be read"}`);
+    }
+  }
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    const where = source !== void 0 ? ` in ${source}` : "";
+    throw expected(`${prefix}invalid JSON${where}: ${e instanceof Error ? e.message : String(e)}`);
   }
-  return JSON.parse(data);
+}
+function toolsetMcpUrl(slug) {
+  return `https://data-mcp.wayai.pro/t/${slug}/mcp`;
 }
 function globals(cmd) {
   let namespace = cmd;
   while (namespace.parent?.parent) namespace = namespace.parent;
   return namespace.opts();
 }
+function withBaseOption(command2) {
+  return command2.option("--base <id>", "Base id (or set WAYAI_BASE)");
+}
+function baseOptionHolder(cmd) {
+  for (let c = cmd; c; c = c.parent ?? void 0) {
+    if (c.options.some((o) => o.long === "--base")) return c;
+  }
+  return void 0;
+}
+function findBase(cmd) {
+  return baseOptionHolder(cmd)?.opts()?.base;
+}
+function requireBase(cmd) {
+  const base = findBase(cmd) ?? process.env.WAYAI_BASE ?? "";
+  if (base) return base;
+  console.error("Error: --base is required (or set WAYAI_BASE)");
+  return process.exit(1);
+}
 function outputFormat(cmd) {
   const opts = globals(cmd);
   return opts.json || opts.output === "json" ? "json" : "table";
 }
+function historyQuery(opts) {
+  const qs = new URLSearchParams();
+  if (opts.limit) qs.set("limit", opts.limit);
+  if (opts.offset) qs.set("offset", opts.offset);
+  if (opts.diff) qs.set("diff", "true");
+  const q = qs.toString();
+  return q ? `?${q}` : "";
+}
 function splitList(value) {
   return value.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
 }
+function parseByteCount(flag, value) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 0) {
+    throw expected(`${flag} must be a whole number of bytes (0 = unlimited), not ${JSON.stringify(value)}.`);
+  }
+  return n;
+}
+async function readSecret(source, label) {
+  const value = resolveSecretSource(source) === "stdin" ? (await readStdin()).trim() : (await promptSecret(`${label}: `)).trim();
+  if (!value) throw expected(`${label} is required.`);
+  return value;
+}
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function parseDuration(input, flag = "duration") {
+  const match = DURATION_RE.exec(input.trim());
+  const value = Number(match?.[1] ?? 0);
+  const unit = match?.[2];
+  const unitMs = unit ? DURATION_UNIT_MS[unit] : void 0;
+  if (!unitMs || value <= 0) {
+    throw expected(
+      `Invalid ${flag} ${JSON.stringify(input)} \u2014 use <number><unit> with unit s/m/h/d (e.g. 10m, 2h, 30d).`
+    );
+  }
+  return value * unitMs;
+}
+var DURATION_RE, DURATION_UNIT_MS;
 var init_helpers = __esm({
   "src/data/helpers.ts"() {
     "use strict";
     init_base_id();
     init_expected();
+    init_utils();
+    DURATION_RE = /^(\d+)([smhd])$/;
+    DURATION_UNIT_MS = {
+      s: 1e3,
+      m: 6e4,
+      h: 36e5,
+      d: 864e5
+    };
   }
 });
 
-// src/lib/base-binding.ts
-var binding2, getBaseBindingPath, readBaseBinding, writeBaseBinding, clearBaseBinding, autoBindBaseIfUnbound, assertBaseMatchesBinding, assertNoBindingBlocksBaseCreation;
-var init_base_binding = __esm({
-  "src/lib/base-binding.ts"() {
+// src/data/commands/actions.ts
+import { Command } from "commander";
+function buildActionsCommand() {
+  const actions = new Command("actions").description(
+    "Manage Actions \u2014 reusable, named definitions: one record_type + one operation, or a composite of atomic write steps (--config with `steps`)"
+  );
+  actions.command("upsert <id>").description(
+    "Create or update an Action \u2014 one record_type + one operation, or a composite (--config with `steps`)"
+  ).option(
+    "--record-type <record_type>",
+    "The record_type this action operates over (single-op; omit for a composite)"
+  ).option(
+    "--operation <op>",
+    "The operation: create | get | list | update | delete (single-op; omit for a composite)"
+  ).option("--description <desc>", "Agent-facing description").option(
+    "--config <json>",
+    'Full Action config as JSON. Single-op: writable_fields, filterable_fields (per field: field (required), param, match, enum, pattern, optional, description \u2014 a declared field generates a required param unless optional: true; a range match is always optional), base_filter (a Filter DSL predicate merged server-side into every list call, invisible to the agent; list only, over a native record_type or a source-backed one whose list endpoint declares local_filters; the value "$now" resolves to the instant of each call, on a date-time field with a range op), precondition, binding, external_source, expose_*/default_* (machinery params are hidden unless expose_<param>: true). Composite: `steps` \u2014 an ordered list of atomic write steps ({key, record_type|rel_type, operation, writable_fields?, precondition?}) run in one transaction. Use @file.json to read from file.'
+  ).action(async function(id, opts) {
+    let body;
+    if (opts.config) {
+      body = parseData(opts.config);
+      if (opts.recordType) body.record_type = opts.recordType;
+      if (opts.operation) body.operation = opts.operation;
+      if (opts.description) body.description = opts.description;
+    } else {
+      if (!opts.recordType || !opts.operation) {
+        throw expected("Provide --record-type and --operation (or --config <json>).");
+      }
+      body = { record_type: opts.recordType, operation: opts.operation };
+      if (opts.description) body.description = opts.description;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("PUT", `/v1/${base}/actions/${pathSegment(id, "action id")}`, body),
+      outputFormat(this)
+    );
+  });
+  actions.command("get <id>").description("Get an Action by id").action(async function(id) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/actions/${pathSegment(id, "action id")}`), outputFormat(this));
+  });
+  actions.command("list").description("List Actions in this base").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/actions`), outputFormat(this));
+  });
+  actions.command("delete <id>").description("Delete an Action").option("-y, --yes", "Skip confirmation").action(async function(id, opts) {
+    if (!opts.yes && !await confirm(`Delete action ${id}? This cannot be undone.`)) {
+      console.log("Aborted.");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/${base}/actions/${pathSegment(id, "action id")}`);
+    console.log(`Deleted action ${id}`);
+  });
+  return actions;
+}
+var init_actions = __esm({
+  "src/data/commands/actions.ts"() {
     "use strict";
-    init_base_id();
-    init_worktree_binding();
-    binding2 = createWorktreeBinding({
-      filename: "wayai-base-binding",
-      isValidId: isValidBaseId,
-      noun: "base",
-      idLabel: "base id (must be a slug)",
-      unbindCommand: "wayai bases unbind",
-      useCommand: "wayai bases use"
-    });
-    getBaseBindingPath = binding2.getBindingPath;
-    readBaseBinding = binding2.readBinding;
-    writeBaseBinding = binding2.writeBinding;
-    clearBaseBinding = binding2.clearBinding;
-    autoBindBaseIfUnbound = binding2.autoBindIfUnbound;
-    assertBaseMatchesBinding = binding2.assertMatchesBinding;
-    assertNoBindingBlocksBaseCreation = binding2.assertNoBindingBlocksCreation;
+    init_expected();
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
   }
 });
 
-// src/data/commands/bases.ts
-import { Command } from "commander";
-import * as fs24 from "fs";
-import * as path30 from "path";
-import * as yaml9 from "js-yaml";
-function pageOf(path31, cursor) {
-  if (!cursor) return path31;
-  return `${path31}${path31.includes("?") ? "&" : "?"}cursor=${encodeURIComponent(cursor)}`;
+// src/data/commands/attachments.ts
+import { Command as Command2 } from "commander";
+import { readFileSync as readFileSync20 } from "fs";
+function findAttachmentByFilename(attachments, filename) {
+  return attachments.find((a) => a.key.endsWith(`/${filename}`)) ?? null;
 }
-function parseEnum(flag, value, allowed) {
-  if (value === void 0) return void 0;
-  if (!allowed.includes(value)) {
-    throw expected(`${flag} must be one of: ${allowed.join(", ")}.`);
+function uploadPathFrom(uploadUrl) {
+  if (typeof uploadUrl !== "string") {
+    throw expected(
+      `The server returned an upload target this CLI will not send credentials to: ${String(uploadUrl)}`
+    );
   }
-  return value;
+  let resolved;
+  try {
+    resolved = new URL(toDataProxyPath(uploadUrl), CONTAINMENT_ORIGIN);
+  } catch {
+    throw expected(
+      `The server returned an upload target this CLI will not send credentials to: ${uploadUrl}`
+    );
+  }
+  if (resolved.origin !== CONTAINMENT_ORIGIN || !resolved.pathname.startsWith(`${DATA_PROXY_PREFIX}/`)) {
+    throw expected(
+      `The server returned an upload target this CLI will not send credentials to: ${uploadUrl}`
+    );
+  }
+  return uploadUrl;
 }
-function buildBasesCommand() {
-  const bases = new Command("bases").description("Manage bases");
-  bases.command("list").description("List all bases").option("--tag <tag>", "Filter by tag").action(async function(opts) {
+function buildAttachmentsCommand() {
+  const attachments = new Command2("attachments").description("Manage record attachments");
+  attachments.command("upload <record_type> <id>").description(
+    "Get a presigned upload URL for a record attachment. With --file, uploads the file content in one step."
+  ).requiredOption("--filename <name>", "File name or path (e.g. docs/guide.md)").option("--content-type <type>", "MIME type", "application/octet-stream").option("--file <path>", "Local file to upload (skips presigned URL output, uploads directly)").action(async function(recordType2, id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
-    const qs = opts.tag ? `?tag=${encodeURIComponent(opts.tag)}` : "";
+    const data = await client.request(
+      "POST",
+      `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${pathSegment(id, "record id")}/attachments`,
+      { filename: opts.filename, content_type: opts.contentType }
+    );
+    if (!opts.file) {
+      printOutput(data, outputFormat(this));
+      return;
+    }
+    const body = readFileSync20(opts.file);
+    await client.upload(uploadPathFrom(data?.upload_url), body, opts.contentType);
+    printOutput({ ...data, uploaded: true }, outputFormat(this));
+  });
+  attachments.command("url <record_type> <id>").description("Get a download URL for an attachment by filename").requiredOption("--filename <name>", "File name or path (e.g. docs/guide.md)").action(async function(recordType2, id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const rows = await client.request(
+      "GET",
+      `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${pathSegment(id, "record id")}/attachments`
+    );
+    const match = findAttachmentByFilename(rows ?? [], opts.filename);
+    if (!match) {
+      throw expected(`Attachment "${opts.filename}" not found`);
+    }
     printOutput(
-      await client.collectPages((cursor) => pageOf(`/v1/bases${qs}`, cursor)),
+      { download_url: client.url(`/v1/${base}/attachments/${pathSegments(match.key, "attachment key")}`), ...match },
       outputFormat(this)
     );
   });
-  bases.command("get <id>").description("Get a base").action(async function(id) {
+  attachments.command("list <record_type> <id>").description("List attachments for a record").option("--prefix <path>", "Filter by path prefix (e.g. docs/)").action(async function(recordType2, id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
-    printOutput(await client.request("GET", `/v1/bases/${pathSegment(id)}`), outputFormat(this));
+    const query = opts.prefix ? `?prefix=${encodeURIComponent(opts.prefix)}` : "";
+    printOutput(
+      await client.request(
+        "GET",
+        `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${pathSegment(id, "record id")}/attachments${query}`
+      ),
+      outputFormat(this)
+    );
   });
-  bases.command("create <id>").description("Create a base").requiredOption("--name <name>", "Base name").option("--description <desc>", "Description").option("--tags <tags>", "Comma-separated tags (e.g. client:acme,billing)").option(
-    "--timezone <tz>",
-    "Default IANA timezone for datetime canonicalization (e.g. America/Sao_Paulo); a record type's own timezone overrides it"
-  ).option(
-    "--environment <env>",
-    "production (default) | preview. Production bases require a paid plan. A preview created here has no production origin and cannot be given one later, so it cannot be promoted directly \u2014 move its config to a linked preview with pull/push when you upgrade"
-  ).action(async function(id, opts) {
-    const environment = parseEnum("--environment", opts.environment, [
-      "production",
-      "preview"
-    ]);
+  attachments.command("delete <record_type> <id> <attachment-id>").description("Delete an attachment").option("-y, --yes", "Skip confirmation prompt").action(async function(recordType2, id, attachmentId, opts) {
+    if (!opts.yes && !await confirm(
+      `Delete attachment ${attachmentId} on ${recordType2}/${id}? This cannot be undone.`
+    )) {
+      console.log("Aborted");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
-    const body = { name: opts.name, description: opts.description };
-    if (environment) body.environment = environment;
-    if (opts.tags) body.tags = splitList(opts.tags);
-    if (opts.timezone) body.settings = { timezone: opts.timezone };
-    printOutput(await client.request("PUT", `/v1/bases/${pathSegment(id)}`, body), outputFormat(this));
+    await client.request(
+      "DELETE",
+      `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${pathSegment(id, "record id")}/attachments/${pathSegment(attachmentId, "attachment id")}`
+    );
+    console.log("Deleted");
   });
-  bases.command("update <id>").description(
-    "Update a base's mutable config (display name, description, tags, default timezone/settings). The id/slug is immutable."
-  ).option("--name <name>", "New display name").option("--description <desc>", "Description").option("--tags <tags>", "Comma-separated tags \u2014 replaces the existing tags").option(
-    "--timezone <tz>",
-    "Default IANA timezone for datetime canonicalization. Merges into existing settings."
+  return attachments;
+}
+var CONTAINMENT_ORIGIN;
+var init_attachments = __esm({
+  "src/data/commands/attachments.ts"() {
+    "use strict";
+    init_expected();
+    init_contracts();
+    init_api_client();
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+    CONTAINMENT_ORIGIN = "https://containment.invalid";
+  }
+});
+
+// src/data/commands/batch.ts
+import { Command as Command3 } from "commander";
+function buildBasesBatchCommand() {
+  return withBaseOption(new Command3("batch")).description("Execute atomic batch operations (up to 1,000 operations)").requiredOption("--operations <json>", "Operations array (inline JSON or @filename)").action(async function(opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const operations = parseData(opts.operations, "--operations");
+    const client = await createDataClient();
+    const data = await client.request("POST", `/v1/${base}/batch`, {
+      operations: Array.isArray(operations) ? operations : [operations]
+    });
+    const format = outputFormat(this);
+    if (format === "json") {
+      printOutput(data, format);
+      return;
+    }
+    printBatchResult(data);
+  });
+}
+var init_batch = __esm({
+  "src/data/commands/batch.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+  }
+});
+
+// src/data/commands/import.ts
+import { createReadStream } from "fs";
+import { access, constants, stat } from "fs/promises";
+import { createInterface as createInterface3 } from "readline";
+import { randomUUID } from "crypto";
+import { Command as Command4 } from "commander";
+function isRetryable(err) {
+  if (isNetworkError(err)) return true;
+  if (!(err instanceof ApiError)) return false;
+  const code = dataErrorCode(err);
+  if (code && RETRYABLE_CODES.has(code)) return true;
+  return err.status >= 500 && err.status !== 501;
+}
+function isExpiredSession(err) {
+  if (!(err instanceof ApiError) || err.status !== 409) return false;
+  if (dataErrorCode(err) !== "IMPORT_SESSION_CLOSED") return false;
+  return dataErrorDetails(err)?.status === "expired";
+}
+async function withRetry(state, fn, what) {
+  let lastErr;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isRetryable(err) || attempt === MAX_ATTEMPTS) throw err;
+      const code = err instanceof ApiError ? dataErrorCode(err) : null;
+      if (!code || !RETRYABLE_CODES.has(code)) state.sawAmbiguous = true;
+      const delay2 = BASE_BACKOFF_MS * 2 ** (attempt - 1);
+      console.error(
+        `  ${what}: ${err.message} \u2014 retrying in ${delay2}ms (${attempt}/${MAX_ATTEMPTS - 1})`
+      );
+      await sleep2(delay2);
+    }
+  }
+  throw lastErr;
+}
+async function* readChunks(file, size, startChunk) {
+  const rl = createInterface3({ input: createReadStream(file, "utf8"), crlfDelay: Infinity });
+  let rows = [];
+  let index = 0;
+  let lineNo = 0;
+  let inChunk = 0;
+  for await (const line of rl) {
+    lineNo++;
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (index < startChunk) {
+      if (++inChunk === size) {
+        inChunk = 0;
+        index++;
+      }
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      throw expected(`${file}:${lineNo}: not valid JSON. Each line must be one JSON object.`);
+    }
+    rows.push(parsed);
+    if (rows.length === size) {
+      yield { index, rows };
+      rows = [];
+      index++;
+    }
+  }
+  if (rows.length > 0) yield { index, rows };
+}
+async function beginSession(state, client, base, recordType2, requestKey) {
+  const res = await withRetry(
+    state,
+    () => client.request("POST", `/v1/${base}/import/begin`, {
+      request_key: requestKey,
+      record_type: recordType2
+    }),
+    "begin"
+  );
+  return res.session;
+}
+function buildBasesImportCommand() {
+  const importCmd = withBaseOption(new Command4("import")).description(
+    "Bulk historical import: load an NDJSON backfill, list sessions, or undo one"
+  );
+  importCmd.command("run <record_type>").description(
+    "Load an NDJSON file into a record type (one JSON object per line, each {external_id, data})"
+  ).requiredOption("--file <path>", "NDJSON file to import").option(
+    "--chunk-size <n>",
+    "Rows per request, max 1000. Must match the original run when resuming.",
+    String(MAX_CHUNK_ROWS)
   ).option(
-    "--settings <json>",
-    "Raw settings JSON object (inline JSON or @file.json) \u2014 replaces the entire settings object"
+    "--request-key <key>",
+    "Idempotency key for this logical run (default: generated). Re-use it to resume."
   ).option(
-    "--integrations <mode>",
-    "enabled | disabled. Preview-only: `disabled` neutralizes every external integration edge so the seeded preview behaves natively for production-safe agent evals"
-  ).action(async function(id, opts) {
-    const integrations = parseEnum("--integrations", opts.integrations, ["enabled", "disabled"]);
-    if (opts.name === void 0 && opts.description === void 0 && opts.tags === void 0 && opts.timezone === void 0 && opts.settings === void 0 && integrations === void 0) {
+    "--start-chunk <n>",
+    "Skip chunks before this index \u2014 resume a run that stopped partway",
+    "0"
+  ).option("--no-finalize", "Leave the session open (resume later with the same --request-key)").action(async function(recordType2, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const state = { sawAmbiguous: false };
+    const chunkSize = Number(opts.chunkSize);
+    if (!Number.isInteger(chunkSize) || chunkSize < 1 || chunkSize > MAX_CHUNK_ROWS) {
+      throw expected(`--chunk-size must be an integer between 1 and ${MAX_CHUNK_ROWS}.`);
+    }
+    const startChunk = Number(opts.startChunk);
+    if (!Number.isInteger(startChunk) || startChunk < 0) {
+      throw expected("--start-chunk must be a non-negative integer.");
+    }
+    if (startChunk > 0 && !this.getOptionValueSource("chunkSize")?.startsWith("cli")) {
       throw expected(
-        "Nothing to update. Provide at least one of --name, --description, --tags, --timezone, --settings, --integrations."
+        "--start-chunk requires --chunk-size to be given explicitly, and it must match the original run."
       );
     }
+    try {
+      if ((await stat(opts.file)).isDirectory()) throw new Error("is a directory");
+      await access(opts.file, constants.R_OK);
+    } catch {
+      throw expected(`--file ${opts.file}: not a readable file.`);
+    }
     const client = await createDataClient();
-    const body = {};
-    if (opts.name !== void 0) body.name = opts.name;
-    if (opts.description !== void 0) body.description = opts.description;
-    if (opts.tags !== void 0) body.tags = splitList(opts.tags);
-    if (integrations !== void 0) body.integrations = integrations;
-    if (opts.settings !== void 0 || opts.timezone !== void 0) {
-      let settings;
-      if (opts.settings !== void 0) {
-        let parsed;
+    const requestKey = opts.requestKey ?? `cli-${randomUUID()}`;
+    if (!opts.requestKey) {
+      console.error(`request_key: ${requestKey}  (pass --request-key to resume this run)`);
+    }
+    let session = await beginSession(state, client, base, recordType2, requestKey);
+    console.error(`import_id: ${session.import_id}`);
+    const importIds = [session.import_id];
+    let written = 0;
+    let skipped = 0;
+    let sent = 0;
+    let nextIndex = startChunk;
+    try {
+      for await (const { index, rows } of readChunks(opts.file, chunkSize, startChunk)) {
+        nextIndex = index;
+        const body = { import_id: session.import_id, chunk_index: index, rows };
+        let result;
         try {
-          parsed = parseData(opts.settings);
-        } catch (e) {
-          throw expected(`--settings: ${e instanceof Error ? e.message : "could not be read as JSON"}`);
+          result = await withRetry(
+            state,
+            () => client.request("POST", `/v1/${base}/import/chunk`, body),
+            `chunk ${index}`
+          );
+        } catch (err) {
+          if (!isExpiredSession(err)) throw err;
+          console.error(
+            `  chunk ${index}: session expired (month boundary) \u2014 starting a fresh session and re-sending.`
+          );
+          console.error(
+            `  NOTE: this run now spans two import_ids; undo needs both. Previous: ${session.import_id}`
+          );
+          session = await beginSession(state, client, base, recordType2, requestKey);
+          importIds.push(session.import_id);
+          console.error(`  import_id: ${session.import_id}`);
+          result = await withRetry(
+            state,
+            () => client.request("POST", `/v1/${base}/import/chunk`, {
+              ...body,
+              import_id: session.import_id
+            }),
+            `chunk ${index}`
+          );
         }
-        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-          throw expected("--settings must be a valid JSON object");
+        written += result.rows_written ?? 0;
+        skipped += result.rows_skipped ?? 0;
+        sent++;
+        nextIndex = index + 1;
+        if (sent % 10 === 0) {
+          console.error(`  ${sent} chunks \u2014 ${written} written, ${skipped} unchanged`);
         }
-        settings = parsed;
+      }
+      if (opts.finalize) {
+        await withRetry(
+          state,
+          () => client.request(
+            "POST",
+            `/v1/${base}/import/${pathSegment(session.import_id, "import id")}/finalize`
+          ),
+          "finalize"
+        );
+      }
+    } catch (err) {
+      console.error(
+        `
+Stopped at chunk ${nextIndex}. To resume, re-run the SAME command with:
+  --start-chunk ${nextIndex} --chunk-size ${chunkSize} --request-key ${requestKey}
+(keep every other flag you passed \u2014 the base and org decide where the rows land, and the chunk size decides which rows each index covers.)`
+      );
+      throw err;
+    }
+    printOutput(
+      {
+        import_ids: importIds,
+        rows_written: written,
+        rows_skipped: skipped,
+        chunks_sent: sent,
+        finalized: opts.finalize
+      },
+      outputFormat(this)
+    );
+  });
+  importCmd.command("list").description("List import sessions, newest first \u2014 find a stuck run or the id to undo").option("--limit <n>", "Maximum sessions to return").option("--offset <n>", "Sessions to skip").action(async function(opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const qs = new URLSearchParams();
+    if (opts.limit) qs.set("limit", opts.limit);
+    if (opts.offset) qs.set("offset", opts.offset);
+    const suffix = qs.toString() ? `?${qs}` : "";
+    const client = await createDataClient();
+    printOutput(
+      await client.request("GET", `/v1/${base}/import/sessions${suffix}`),
+      outputFormat(this)
+    );
+  });
+  importCmd.command("rollback <import_id>").description(
+    "Undo an import \u2014 deletes only the rows it CREATED. Re-importing corrected data is usually the better fix."
+  ).option("--yes", "Skip the confirmation prompt").action(async function(importId, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const format = outputFormat(this);
+    const state = { sawAmbiguous: false };
+    const client = await createDataClient();
+    if (!opts.yes && !isInteractive()) {
+      throw expected(
+        "Refusing to roll back an import without confirmation \u2014 pass --yes to run non-interactively."
+      );
+    }
+    if (!opts.yes) {
+      const plan = await client.request("GET", `/v1/${base}/import/${pathSegment(importId, "import id")}/rollback-plan?counts=true`);
+      const n = plan.matched_records ?? 0;
+      if (n === 0) {
+        console.error("No rows left to undo \u2014 closing the import session.");
       } else {
-        const existing = await client.request("GET", `/v1/bases/${pathSegment(id)}`);
-        settings = { ...existing?.settings ?? {} };
+        const ok = await confirm(
+          `Delete ${n} record${n === 1 ? "" : "s"} created by this import into "${sanitizeTerminalText(String(plan.record_type))}", plus every relationship pointing at them?`
+        );
+        if (!ok) {
+          console.error("Aborted.");
+          return;
+        }
       }
-      if (opts.timezone !== void 0) settings.timezone = opts.timezone;
-      body.settings = settings;
     }
-    printOutput(await client.request("PUT", `/v1/bases/${pathSegment(id)}`, body), outputFormat(this));
+    let records = 0;
+    let relationships = 0;
+    let calls = 0;
+    let incomplete = false;
+    for (let sweep = 0; ; sweep++) {
+      const res = await withRetry(
+        state,
+        () => client.request("POST", `/v1/${base}/import/${pathSegment(importId, "import id")}/rollback`),
+        "rollback"
+      );
+      records += res.swept.records;
+      relationships += res.swept.relationships;
+      calls++;
+      if (res.complete) break;
+      const sweptNothing = res.swept.records === 0 && res.swept.relationships === 0;
+      if (sweptNothing || sweep + 1 >= MAX_ROLLBACK_SWEEPS) {
+        incomplete = true;
+        console.error(
+          sweptNothing ? "  the sweep stopped making progress before the server reported it complete \u2014 re-run to continue." : `  stopped after ${MAX_ROLLBACK_SWEEPS} sweeps without completing \u2014 re-run to continue.`
+        );
+        break;
+      }
+      if (format !== "json") {
+        console.error(`  swept ${records} records, ${relationships} relationships so far\u2026`);
+      }
+    }
+    if (state.sawAmbiguous && format !== "json") {
+      console.error(
+        "Note: a request was re-sent after its outcome was unknown, so the counts below are a lower bound \u2014 a page that committed before its response was lost is not included."
+      );
+    }
+    printOutput(
+      {
+        import_id: importId,
+        swept: { records, relationships },
+        requests: calls,
+        // The server's own completion claim, carried so a script can tell an
+        // undo that FINISHED from one that stopped early and needs re-running.
+        complete: !incomplete,
+        ...state.sawAmbiguous ? { counts_are_lower_bound: true } : {}
+      },
+      format
+    );
+    if (incomplete) return process.exit(1);
+  });
+  return importCmd;
+}
+var MAX_CHUNK_ROWS, MAX_ATTEMPTS, MAX_ROLLBACK_SWEEPS, BASE_BACKOFF_MS, RETRYABLE_CODES, sleep2;
+var init_import = __esm({
+  "src/data/commands/import.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_api_client();
+    init_network_error();
+    init_terminal_output();
+    init_utils();
+    init_expected();
+    MAX_CHUNK_ROWS = 1e3;
+    MAX_ATTEMPTS = 5;
+    MAX_ROLLBACK_SWEEPS = 1e3;
+    BASE_BACKOFF_MS = 500;
+    RETRYABLE_CODES = /* @__PURE__ */ new Set(["BASE_OVERLOADED", "SERVICE_UNAVAILABLE", "RATE_LIMITED"]);
+    sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+  }
+});
+
+// src/data/commands/providers.ts
+import { Command as Command5 } from "commander";
+import { writeFileSync as writeFileSync15 } from "fs";
+function providerSegment(provider) {
+  if (!VALID_PROVIDERS.includes(provider)) {
+    throw expected(`Unknown provider ${JSON.stringify(provider)}. Expected one of: ${VALID_PROVIDERS_HELP}.`);
+  }
+  return pathSegment(provider, "provider");
+}
+function buildBasesProvidersCommand() {
+  const providers = withBaseOption(new Command5("providers")).description(
+    "Import/export tool definitions between LLM providers and record types"
+  );
+  providers.command("import <provider>").description(`Import tool definitions as record types. Providers: ${VALID_PROVIDERS_HELP}`).requiredOption("--tools <json>", "Tool definitions (inline JSON or @filename)").action(async function(provider, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const tools = parseData(opts.tools, "--tools");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/${base}/providers/${providerSegment(provider)}/import`, {
+        tools: Array.isArray(tools) ? tools : [tools]
+      }),
+      outputFormat(this)
+    );
+  });
+  providers.command("export <provider>").description(`Export record types as tool definitions. Providers: ${VALID_PROVIDERS_HELP}`).option("--record-types <ids>", "Comma-separated record type ids (omit for all)").option("--to <file>", "Write the exported definitions to a file instead of stdout").action(async function(provider, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const recordTypes = opts.recordTypes ? splitList(opts.recordTypes) : [];
+    const query = recordTypes.length ? `?record_types=${encodeURIComponent(recordTypes.join(","))}` : "";
+    const client = await createDataClient();
+    const data = await client.request(
+      "GET",
+      `/v1/${base}/providers/${providerSegment(provider)}/export${query}`
+    );
+    if (opts.to) {
+      try {
+        writeFileSync15(opts.to, JSON.stringify(data, null, 2));
+      } catch (e) {
+        throw expected(`--to ${opts.to}: ${e instanceof Error ? e.message : "could not be written"}`);
+      }
+      printOutput({ written_to: opts.to }, outputFormat(this));
+      return;
+    }
+    printOutput(data, outputFormat(this));
+  });
+  providers.command("import-call <provider> <record_type>").description(
+    `Create a record from a tool call in provider format. Providers: ${VALID_PROVIDERS_HELP}`
+  ).requiredOption("--data <json>", "Tool call data in provider format (inline JSON or @filename)").option("--external-id <id>", "External id for idempotent upsert").option("--external-source <source>", "External source identifier").action(async function(provider, recordType2, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const callData = parseData(opts.data, "--data");
+    const queryParts = [];
+    if (opts.externalId) queryParts.push(`external_id=${encodeURIComponent(opts.externalId)}`);
+    if (opts.externalSource) {
+      queryParts.push(`external_source=${encodeURIComponent(opts.externalSource)}`);
+    }
+    const qs = queryParts.length ? `?${queryParts.join("&")}` : "";
+    const client = await createDataClient();
+    printOutput(
+      await client.request(
+        "POST",
+        `/v1/${base}/providers/${providerSegment(provider)}/records/${pathSegment(recordType2, "record_type")}${qs}`,
+        callData
+      ),
+      outputFormat(this)
+    );
+  });
+  return providers;
+}
+var VALID_PROVIDERS, VALID_PROVIDERS_HELP;
+var init_providers = __esm({
+  "src/data/commands/providers.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_expected();
+    VALID_PROVIDERS = ["openai", "anthropic", "google", "mcp"];
+    VALID_PROVIDERS_HELP = VALID_PROVIDERS.join(", ");
+  }
+});
+
+// src/data/commands/report.ts
+import { Command as Command6 } from "commander";
+import { readFileSync as readFileSync21 } from "fs";
+import { dirname as dirname9, join as join27 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function resolveCliVersion() {
+  for (const candidate of [
+    join27(here, "..", "package.json"),
+    join27(here, "..", "..", "..", "package.json")
+  ]) {
+    try {
+      const version = JSON.parse(readFileSync21(candidate, "utf-8")).version;
+      if (typeof version === "string" && version) return version;
+    } catch {
+    }
+  }
+  return "unknown";
+}
+function resolveReportClientVersions(projectRoot, cliVersion) {
+  const versions = { cli_version: cliVersion };
+  try {
+    const skillVersion = lowestInstalledVersion(findInstalledSkills(projectRoot));
+    if (skillVersion) versions.skill_version = skillVersion;
+  } catch {
+  }
+  return versions;
+}
+function reportActionError2(err) {
+  if (err instanceof ApiError) {
+    if (err.status === 404) {
+      console.error("Report not found, or it was not filed by you.");
+    } else if (err.status === 403) {
+      console.error("This report is agent-authored and can only be handled by a platform admin.");
+    } else if (err.status === 409) {
+      console.error(err.message);
+    } else if (err.status === 429) {
+      console.error("Rate limit exceeded. Please try again later.");
+    } else {
+      console.error(`Request failed: ${err.message}`);
+    }
+    return process.exit(1);
+  }
+  throw err;
+}
+function buildBasesReportCommand() {
+  const report = new Command6("report").description(
+    "File a report to the Data triage queue and verify the outcome"
+  );
+  report.command("create").description("Submit a report to the Data triage queue (deduplicated)").requiredOption("--title <title>", "Short summary").requiredOption("--description <text>", "What happened").option("--source <source>", "Origin: cli_report (default) | review | security_audit").option("--classification <c>", "Nature: bug (default) | flaky_test | security | enhancement").option(
+    "--dedup-key <key>",
+    'Stable dedup key (e.g. "<file>::<test>"); collapses repeat occurrences'
+  ).option("--severity <level>", "low | medium | high | critical").option("--steps <text>", "Steps to reproduce").option("--error-message <text>", "Exact error text if any").option("--context <text>", "Additional context (logs, request ids)").option("--locale <code>", "Notification locale (en | pt | es)", "en").option("--reporter-email <addr>", "Override reporter email (defaults to session email)").option("--base-id <id>", "Base the error relates to (defaults to the configured base)").option("--record-type <name>", "Record type the error relates to").option("--record-id <id>", "Record id (UUID) the error relates to").option("--external-id <id>", "External id of the related record").option("--external-source <src>", "External source of the related record").option("--relationship-id <id>", "Relationship id the error relates to").action(async function(opts) {
+    const body = {
+      title: opts.title,
+      description: opts.description,
+      locale: opts.locale
+    };
+    if (opts.source) body.source = opts.source;
+    if (opts.classification) body.classification = opts.classification;
+    if (opts.dedupKey) body.dedup_key = opts.dedupKey;
+    if (opts.severity) body.severity = opts.severity;
+    if (opts.steps) body.steps = opts.steps;
+    if (opts.errorMessage) body.error_message = opts.errorMessage;
+    if (opts.context) body.context = opts.context;
+    if (opts.reporterEmail) body.reporter_email = opts.reporterEmail;
+    const baseId = opts.baseId ?? findBase(this) ?? process.env.WAYAI_BASE;
+    if (baseId) body.base_id = baseId;
+    if (opts.recordType) body.record_type = opts.recordType;
+    if (opts.recordId) body.record_id = opts.recordId;
+    if (opts.externalId) body.external_id = opts.externalId;
+    if (opts.externalSource) body.external_source = opts.externalSource;
+    if (opts.relationshipId) body.relationship_id = opts.relationshipId;
+    const versions = resolveReportClientVersions(
+      findGitRoot() ?? process.cwd(),
+      resolveCliVersion()
+    );
+    body.cli_version = versions.cli_version;
+    if (versions.skill_version) body.skill_version = versions.skill_version;
+    const client = await createDataClient();
+    const data = await client.request("POST", "/v1/reports", body);
+    if (outputFormat(this) === "json") {
+      printOutput(data, "json");
+      return;
+    }
+    if (data.created) {
+      console.log(`Report submitted (id: ${data.report_id}).`);
+      console.log("Our team will review and follow up by email if you provided one.");
+    } else if (data.recurrence?.reopened) {
+      console.log(`Report reopened for another look (id: ${data.report_id}).`);
+    } else if (data.recurrence) {
+      console.log(
+        `A matching report remains closed (id: ${data.report_id}); this occurrence was recorded.`
+      );
+    } else {
+      console.log(
+        `A matching report already exists (id: ${data.report_id}) \u2014 your submission was merged into it.`
+      );
+    }
+  });
+  report.command("list").description("List your reports, newest first").option("--status <s>", "Filter by status (e.g. shipped \u2014 awaiting your verification)").action(async function(opts) {
+    const client = await createDataClient();
+    const qs = opts.status ? `?status=${encodeURIComponent(opts.status)}` : "";
+    try {
+      const rows = await client.request("GET", `/v1/reports${qs}`);
+      if (outputFormat(this) === "json") {
+        printOutput(rows, "json");
+        return;
+      }
+      if (rows.length === 0) {
+        console.log("No reports found.");
+        return;
+      }
+      for (const r of rows) {
+        const title = sanitizeTerminalText(r.title?.replace(/\s+/g, " ").trim() || "(untitled)");
+        console.log(
+          `${r.report_id}  ${r.status.padEnd(10)}  ${(r.classification ?? "bug").padEnd(12)}  ${title}`
+        );
+      }
+    } catch (err) {
+      reportActionError2(err);
+    }
+  });
+  report.command("get <report_id>").description("Show one of your reports: status + the message thread").action(async function(reportId) {
+    const client = await createDataClient();
+    try {
+      const data = await client.request("GET", `/v1/reports/${pathSegment(reportId, "report id")}`);
+      if (outputFormat(this) === "json") {
+        printOutput(data, "json");
+        return;
+      }
+      const { report: row, messages } = data;
+      console.log(`Report ${row.report_id}`);
+      console.log(`  title:          ${sanitizeTerminalText(row.title ?? "(unavailable)")}`);
+      console.log(
+        `  description:    ${sanitizeTerminalText(row.description ?? "(unavailable)")}`
+      );
+      console.log(`  status:         ${row.status}`);
+      console.log(`  classification: ${row.classification ?? "bug"}`);
+      if (row.contest_count > 0) console.log(`  contests:       ${row.contest_count}`);
+      if (row.dismissal_final) console.log("  dismissal:      final (non-contestable)");
+      if (messages.length > 0) {
+        console.log("\n  Thread:");
+        for (const m of messages) {
+          console.log(`    [${m.author_role}] ${sanitizeTerminalText(m.body)}`);
+        }
+      }
+      if (row.status === "shipped") {
+        console.log(
+          `
+  This fix is shipped. Run \`wayai bases report accept ${row.report_id}\` if it works,`
+        );
+        console.log(
+          `  or \`wayai bases report contest ${row.report_id} --reason "..."\` if it does not.`
+        );
+      }
+    } catch (err) {
+      reportActionError2(err);
+    }
+  });
+  report.command("accept <report_id>").description("Accept a shipped fix (\u2192 addressed)").action(async function(reportId) {
+    const client = await createDataClient();
+    try {
+      const data = await client.request(
+        "POST",
+        `/v1/reports/${pathSegment(reportId, "report id")}/accept`
+      );
+      if (outputFormat(this) === "json") {
+        printOutput(data, "json");
+        return;
+      }
+      console.log(`Accepted. Report ${data.report.report_id} \u2192 ${data.report.status}.`);
+    } catch (err) {
+      reportActionError2(err);
+    }
+  });
+  report.command("contest <report_id>").description("Contest a shipped fix or a dismissal (\u2192 back to triage)").requiredOption("--reason <text>", "Why the fix/dismissal is wrong").action(async function(reportId, opts) {
+    const client = await createDataClient();
+    try {
+      const data = await client.request(
+        "POST",
+        `/v1/reports/${pathSegment(reportId, "report id")}/contest`,
+        { reason: opts.reason }
+      );
+      if (outputFormat(this) === "json") {
+        printOutput(data, "json");
+        return;
+      }
+      console.log(
+        `Contested. Report ${data.report.report_id} \u2192 ${data.report.status} (back to triage).`
+      );
+    } catch (err) {
+      reportActionError2(err);
+    }
+  });
+  return report;
+}
+var here;
+var init_report2 = __esm({
+  "src/data/commands/report.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_api_client();
+    init_terminal_output();
+    init_workspace();
+    init_skill_version();
+    here = dirname9(fileURLToPath2(import.meta.url));
+  }
+});
+
+// src/data/commands/secrets.ts
+import { Command as Command7 } from "commander";
+import { readFileSync as readFileSync22 } from "fs";
+function withValueSourceOptions(cmd, what) {
+  return cmd.option(
+    "--file <path>",
+    `Read ${what} from a file and base64-encode it (certificates, keystores, service-account JSON)`
+  ).option("--value-stdin", `Read ${what} from stdin (recommended for CI)`).option("--value-prompt", `Prompt for ${what}, masked`);
+}
+async function resolveValue(opts, label) {
+  if (opts.file !== void 0) {
+    if (opts.valueStdin || opts.valuePrompt) {
+      throw expected("--file cannot be combined with --value-stdin or --value-prompt \u2014 pass one.");
+    }
+    try {
+      return readFileSync22(opts.file).toString("base64");
+    } catch (e) {
+      throw expected(`--file ${opts.file}: ${e instanceof Error ? e.message : "could not be read"}`);
+    }
+  }
+  return readSecret(
+    {
+      stdin: opts.valueStdin,
+      prompt: opts.valuePrompt,
+      stdinFlag: "--value-stdin",
+      promptHint: "--value-prompt"
+    },
+    label
+  );
+}
+function listAllSecrets(client, expiringDays) {
+  return client.collectPages((cursor) => {
+    const params = new URLSearchParams({ limit: String(SECRET_LIST_PAGE_LIMIT) });
+    if (expiringDays !== void 0) params.set("expiring_within_days", expiringDays);
+    if (cursor) params.set("cursor", cursor);
+    return `/v1/vault/secrets?${params.toString()}`;
+  });
+}
+function buildBasesSecretsCommand() {
+  const secrets = new Command7("secrets").description("Manage organization vault secrets");
+  withValueSourceOptions(
+    secrets.command("create").description("Store a vault secret (value read from stdin, a masked prompt, or --file)").requiredOption("--name <name>", "Secret name").option("--content-type <mime>", "MIME type of the value (e.g. application/x-pkcs12)").option(
+      "--expires-at <date>",
+      "Expiry as ISO-8601 (e.g. 2027-01-01T00:00:00Z) \u2014 surfaced by `list --expiring`"
+    ).option("--tags <tags>", "Comma-separated tags"),
+    "the secret value"
+  ).action(async function(opts) {
+    const body = {
+      name: opts.name,
+      value: await resolveValue(opts, "Secret value")
+    };
+    if (opts.contentType) body.content_type = opts.contentType;
+    if (opts.expiresAt) body.expires_at = opts.expiresAt;
+    if (opts.tags) body.tags = splitList(opts.tags);
+    const client = await createDataClient();
+    printOutput(await client.request("POST", "/v1/vault/secrets", body), outputFormat(this));
+  });
+  secrets.command("list").description("List vault secrets (values masked)").option("--expiring", "Only secrets expiring within --days (default 30)").option("--days <n>", "Window for --expiring, in days", "30").action(async function(opts) {
+    const client = await createDataClient();
+    const secretRows = await listAllSecrets(client, opts.expiring ? opts.days : void 0);
+    printOutput(secretRows, outputFormat(this));
+  });
+  secrets.command("get <id>").description("Get vault secret metadata (value masked)").action(async function(id) {
+    const client = await createDataClient();
+    printOutput(
+      await client.request("GET", `/v1/vault/secrets/${pathSegment(id, "secret id")}`),
+      outputFormat(this)
+    );
+  });
+  withValueSourceOptions(
+    secrets.command("rotate <id>").description("Rotate a secret by installing a new caller-supplied value").option("--expires-at <date>", "Set the rotated credential's new expiry (ISO-8601)"),
+    "the new secret value"
+  ).action(async function(id, opts) {
+    const body = { value: await resolveValue(opts, "New secret value") };
+    if (opts.expiresAt) body.expires_at = opts.expiresAt;
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/vault/secrets/${pathSegment(id, "secret id")}/rotate`, body),
+      outputFormat(this)
+    );
+  });
+  secrets.command("delete <id>").description("Delete a vault secret").option("-y, --yes", "Skip confirmation prompt").action(async function(id, opts) {
+    if (!opts.yes) {
+      if (!isInteractive()) {
+        throw expected("Refusing to delete without confirmation \u2014 pass --yes to delete non-interactively.");
+      }
+      if (!await confirm(`Delete vault secret ${id}? This cannot be undone.`)) {
+        console.log("Aborted");
+        return;
+      }
+    }
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/vault/secrets/${pathSegment(id, "secret id")}`);
+    printOutput({ id, deleted: true }, outputFormat(this));
+  });
+  return secrets;
+}
+var SECRET_LIST_PAGE_LIMIT;
+var init_secrets = __esm({
+  "src/data/commands/secrets.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+    init_expected();
+    SECRET_LIST_PAGE_LIMIT = 250;
+  }
+});
+
+// src/data/commands/sql.ts
+import { Command as Command8 } from "commander";
+import { readFileSync as readFileSync23 } from "fs";
+function buildBasesSqlCommand() {
+  return withBaseOption(new Command8("sql")).description("Execute a read-only SQL query against base data").argument("[query]", "SQL query (SELECT only)").option("--file <path>", "Read SQL from a file instead of the argument").option(
+    "--param <kv...>",
+    "Named parameters as key=value pairs (e.g. --param status=issued)"
+  ).action(async function(queryArg, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    let query;
+    if (opts.file) {
+      try {
+        query = readFileSync23(opts.file, "utf-8").trim();
+      } catch (e) {
+        throw expected(`--file ${opts.file}: ${e instanceof Error ? e.message : "could not be read"}`);
+      }
+      if (!query) throw expected(`--file ${opts.file} is empty \u2014 it must contain a SELECT query.`);
+    } else if (queryArg) {
+      query = queryArg;
+    } else {
+      throw expected("Provide a SQL query as an argument or via --file.");
+    }
+    const params = {};
+    for (const kv of opts.param ?? []) {
+      const eqIdx = kv.indexOf("=");
+      if (eqIdx === -1) {
+        throw expected(`Invalid --param ${JSON.stringify(kv)}, expected key=value.`);
+      }
+      params[kv.slice(0, eqIdx)] = kv.slice(eqIdx + 1);
+    }
+    const body = { query };
+    if (Object.keys(params).length > 0) body.params = params;
+    const client = await createDataClient();
+    printOutput(await client.request("POST", `/v1/${base}/sql`, body), outputFormat(this));
+  });
+}
+var init_sql = __esm({
+  "src/data/commands/sql.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_expected();
+  }
+});
+
+// src/data/commands/tokens.ts
+import { Command as Command9 } from "commander";
+function addTokenLifecycleOptions(cmd) {
+  return cmd.option("--expires-at <date>", "Expiration date (ISO 8601, e.g. 2026-06-01T00:00:00Z)").option(
+    "--ttl <duration>",
+    "Relative expiry, e.g. 10m, 2h, 7d (use for disposable probe/test tokens)"
+  ).option(
+    "--description <text>",
+    'What holds this token (e.g. "behind credential X"); shown in list and revoke warnings'
+  ).addHelpText("after", TOKEN_OUTPUT_HELP);
+}
+function tokenCreationOutput(cmd, opts) {
+  return opts.tokenOnly ? "token" : outputFormat(cmd);
+}
+function printCreatedToken(data, output) {
+  if (output !== "token") {
+    printOutput(data, output);
+    return;
+  }
+  const token = typeof data === "object" && data !== null && "token" in data ? data.token : void 0;
+  if (typeof token !== "string" || !RAW_TOKEN_PATTERN.test(token)) {
+    throw new Error("Token creation response did not contain a valid rec_ token");
+  }
+  console.log(token);
+}
+function resolveExpiresAt(opts) {
+  if (opts.ttl && opts.expiresAt) {
+    throw expected("--ttl and --expires-at are mutually exclusive \u2014 pass one.");
+  }
+  if (opts.ttl) return new Date(Date.now() + parseDuration(opts.ttl, "--ttl")).toISOString();
+  return opts.expiresAt;
+}
+function applyTokenLifecycleOpts(body, opts) {
+  const expiresAt = resolveExpiresAt(opts);
+  if (expiresAt) body.expires_at = expiresAt;
+  if (opts.description) body.description = opts.description;
+}
+function listAllTokens(client) {
+  return client.collectPages(
+    (cursor) => `/v1/tokens?limit=${TOKEN_LIST_PAGE_LIMIT}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`
+  );
+}
+function pruneRow(t, reason) {
+  return {
+    token_id: t.token_id,
+    name: t.name,
+    reason,
+    last_used: t.last_used_at ?? "never"
+  };
+}
+function buildBasesTokensCommand() {
+  const tokens = new Command9("tokens").description("Manage API tokens");
+  addTokenLifecycleOptions(
+    tokens.command("create").description("Create a scoped API token").requiredOption("--name <name>", "Token name").requiredOption("--grants <json>", "Grant definitions as JSON array").option(
+      "--token-only",
+      "Print only the raw rec_ token for secure command substitution (shown once)"
+    )
+  ).action(async function(opts) {
+    const grants = parseData(opts.grants, "--grants");
+    const body = { name: opts.name, grants };
+    applyTokenLifecycleOpts(body, opts);
+    const client = await createDataClient();
+    const data = await client.request("POST", "/v1/tokens", body);
+    printCreatedToken(data, tokenCreationOutput(this, opts));
+  });
+  addTokenLifecycleOptions(
+    // The only token verb that addresses a base, so it alone declares `--base`.
+    // Putting it on the `tokens` group would advertise a flag that does nothing
+    // on `list`, `revoke` and `prune` — the defect `withBaseOption` exists to
+    // avoid.
+    withBaseOption(tokens.command("create-for-toolset <slug>")).description(
+      "Create a toolset-bound (consumer) token whose authorization IS the toolset tool surface \u2014 it can call exactly the tools that toolset exposes (those record types + operations, relationships, batch, and sql only if enabled) and nothing else. Binds to the configured --base."
+    ).option("--name <name>", 'Token name (default: "<slug> consumer")').option(
+      "--token-only",
+      "Print only the raw rec_ token for secure command substitution (shown once)"
+    )
+  ).action(async function(slug, opts) {
+    const base = requireBase(this);
+    const body = {
+      name: opts.name ?? `${slug} consumer`,
+      toolset_binding: { base_id: base, toolset_id: slug }
+    };
+    applyTokenLifecycleOpts(body, opts);
+    const client = await createDataClient();
+    const data = await client.request("POST", "/v1/tokens", body);
+    const output = tokenCreationOutput(this, opts);
+    printCreatedToken(data, output);
+    if (output === "table") {
+      console.log(`
+MCP URL: ${toolsetMcpUrl(slug)}`);
+    }
+  });
+  tokens.command("list").description("List API tokens (status, last_used_at, expires_at, description)").action(async function() {
+    const client = await createDataClient();
+    printOutput(await listAllTokens(client), outputFormat(this));
+  });
+  tokens.command("revoke <token_id>").description(
+    "Revoke an API token (permanent). A recently-used or toolset-bound token requires --force."
+  ).option("--force", "Revoke even if the token appears to be in live use").action(async function(tokenId, opts) {
+    const client = await createDataClient();
+    const id = pathSegment(tokenId, "token id");
+    const path31 = (force) => `/v1/tokens/${id}${force ? "?force=true" : ""}`;
+    const format = outputFormat(this);
+    const revoked = (forced) => printOutput({ token_id: tokenId, revoked: true, forced }, format);
+    if (opts.force) {
+      await client.request("DELETE", path31(true));
+      revoked(true);
+      return;
+    }
+    try {
+      await client.request("DELETE", path31(false));
+      revoked(false);
+    } catch (err) {
+      if (!(err instanceof ApiError) || err.status !== 409 || dataErrorDetails(err)?.requires_force !== true) {
+        throw err;
+      }
+      console.error(err.message);
+      if (!isInteractive()) {
+        console.error("\nRe-run with --force to revoke anyway.");
+        return process.exit(1);
+      }
+      if (!await confirm("Revoke anyway?")) {
+        console.error("Aborted.");
+        return process.exit(1);
+      }
+      await client.request("DELETE", path31(true));
+      revoked(true);
+    }
+  });
+  tokens.command("prune").description(
+    "Revoke stale tokens, selected by staleness only (expired, or unused past --unused-since) \u2014 never by name. Previews by default; revoking requires --yes or an interactive confirmation."
+  ).option(
+    "--unused-since <duration>",
+    "Also prune tokens with no activity for this long (e.g. 30d). Skips toolset-bound and legacy usage-untracked tokens."
+  ).option("--include-bound", "Allow pruning stale toolset-bound (consumer) tokens").option("-y, --yes", "Revoke without prompting (required when non-interactive)").action(async function(opts) {
+    const staleMs = opts.unusedSince ? parseDuration(opts.unusedSince, "--unused-since") : void 0;
+    const client = await createDataClient();
+    const allTokens = await listAllTokens(client);
+    const now = Date.now();
+    const targets = [];
+    const skipped = [];
+    for (const t of allTokens) {
+      const expired = t.status ? t.status === "expired" : !!t.expires_at && Date.parse(t.expires_at) <= now;
+      if (expired) {
+        targets.push(pruneRow(t, "expired"));
+        continue;
+      }
+      if (staleMs === void 0) continue;
+      const lastActivity = Date.parse(t.last_used_at ?? t.created_at);
+      if (!(now - lastActivity > staleMs)) continue;
+      if (t.usage_tracked !== true) {
+        skipped.push(
+          pruneRow(
+            t,
+            "usage untracked (legacy token) \u2014 revoke individually if truly unused"
+          )
+        );
+      } else if (t.toolset_binding && !opts.includeBound) {
+        skipped.push(
+          pruneRow(
+            t,
+            `toolset-bound ('${t.toolset_binding.toolset_id}') \u2014 pass --include-bound to prune`
+          )
+        );
+      } else {
+        targets.push(pruneRow(t, `unused for over ${opts.unusedSince}`));
+      }
+    }
+    const format = outputFormat(this);
+    const json = format === "json";
+    const note = (line) => json ? console.error(line) : console.log(line);
+    const printPreview = () => {
+      if (targets.length === 0) {
+        note("Nothing to prune.");
+      } else {
+        note(`Would revoke ${targets.length} token(s):`);
+        if (!json) printOutput(targets, format);
+      }
+      if (skipped.length === 0) return;
+      note(`
+Skipped ${skipped.length} stale token(s):`);
+      if (!json) printOutput(skipped, format);
+    };
+    printPreview();
+    if (targets.length === 0) {
+      if (json) printOutput({ revoked: 0, failed: 0, targets, skipped }, format);
+      return;
+    }
+    if (!opts.yes) {
+      if (!isInteractive()) {
+        console.error("\nPreview only \u2014 re-run with --yes to revoke these tokens.");
+        if (json) printOutput({ preview: true, revoked: 0, failed: 0, targets, skipped }, format);
+        return process.exit(1);
+      }
+      if (!await confirm(`
+Revoke ${targets.length} token(s)?`)) {
+        console.error("Aborted.");
+        return process.exit(1);
+      }
+    }
+    let revoked = 0;
+    let failed = 0;
+    for (const t of targets) {
+      try {
+        await client.request(
+          "DELETE",
+          `/v1/tokens/${pathSegment(t.token_id, "token id")}?force=true`
+        );
+        revoked++;
+      } catch (err) {
+        failed++;
+        console.error(
+          `Failed to revoke ${t.token_id} ('${sanitizeTerminalText(t.name)}'): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    if (json) printOutput({ revoked, failed, targets, skipped }, format);
+    else console.log(`Revoked ${revoked} token(s)${failed > 0 ? `, ${failed} failed` : ""}.`);
+    if (failed > 0) return process.exit(1);
+  });
+  return tokens;
+}
+var RAW_TOKEN_PATTERN, TOKEN_OUTPUT_HELP, TOKEN_LIST_PAGE_LIMIT;
+var init_tokens = __esm({
+  "src/data/commands/tokens.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_api_client();
+    init_terminal_output();
+    init_utils();
+    init_expected();
+    RAW_TOKEN_PATTERN = /^rec_[A-Za-z0-9_-]{43}$/;
+    TOKEN_OUTPUT_HELP = `
+Output:
+  --json prints the unwrapped response object; the secret is at top-level .token, never .data.token.
+  --token-only prints only a validated rec_ token and overrides table/JSON formatting.
+  The raw token is shown once. Capture it securely and do not log it.
+`;
+    TOKEN_LIST_PAGE_LIMIT = 250;
+  }
+});
+
+// src/lib/base-binding.ts
+var binding2, getBaseBindingPath, readBaseBinding, writeBaseBinding, clearBaseBinding, autoBindBaseIfUnbound, assertBaseMatchesBinding, assertNoBindingBlocksBaseCreation;
+var init_base_binding = __esm({
+  "src/lib/base-binding.ts"() {
+    "use strict";
+    init_base_id();
+    init_worktree_binding();
+    binding2 = createWorktreeBinding({
+      filename: "wayai-base-binding",
+      isValidId: isValidBaseId,
+      noun: "base",
+      idLabel: "base id (must be a slug)",
+      unbindCommand: "wayai bases unbind",
+      useCommand: "wayai bases use"
+    });
+    getBaseBindingPath = binding2.getBindingPath;
+    readBaseBinding = binding2.readBinding;
+    writeBaseBinding = binding2.writeBinding;
+    clearBaseBinding = binding2.clearBinding;
+    autoBindBaseIfUnbound = binding2.autoBindIfUnbound;
+    assertBaseMatchesBinding = binding2.assertMatchesBinding;
+    assertNoBindingBlocksBaseCreation = binding2.assertNoBindingBlocksCreation;
+  }
+});
+
+// src/data/commands/bases.ts
+import { Command as Command10 } from "commander";
+import * as fs24 from "fs";
+import * as path30 from "path";
+import * as yaml9 from "js-yaml";
+function pageOf(path31, cursor) {
+  if (!cursor) return path31;
+  return `${path31}${path31.includes("?") ? "&" : "?"}cursor=${encodeURIComponent(cursor)}`;
+}
+function parseEnum(flag, value, allowed) {
+  if (value === void 0) return void 0;
+  if (!allowed.includes(value)) {
+    throw expected(`${flag} must be one of: ${allowed.join(", ")}.`);
+  }
+  return value;
+}
+function buildBasesCommand() {
+  const bases = new Command10("bases").description("Manage bases");
+  bases.command("list").description("List all bases").option("--tag <tag>", "Filter by tag").action(async function(opts) {
+    const client = await createDataClient();
+    const qs = opts.tag ? `?tag=${encodeURIComponent(opts.tag)}` : "";
+    printOutput(
+      await client.collectPages((cursor) => pageOf(`/v1/bases${qs}`, cursor)),
+      outputFormat(this)
+    );
+  });
+  bases.command("get <id>").description("Get a base").action(async function(id) {
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/bases/${pathSegment(id)}`), outputFormat(this));
+  });
+  bases.command("create <id>").description("Create a base").requiredOption("--name <name>", "Base name").option("--description <desc>", "Description").option("--tags <tags>", "Comma-separated tags (e.g. client:acme,billing)").option(
+    "--timezone <tz>",
+    "Default IANA timezone for datetime canonicalization (e.g. America/Sao_Paulo); a record type's own timezone overrides it"
+  ).option(
+    "--environment <env>",
+    "production (default) | preview. Production bases require a paid plan. A preview created here has no production origin and cannot be given one later, so it cannot be promoted directly \u2014 move its config to a linked preview with pull/push when you upgrade"
+  ).action(async function(id, opts) {
+    const environment = parseEnum("--environment", opts.environment, [
+      "production",
+      "preview"
+    ]);
+    const client = await createDataClient();
+    const body = { name: opts.name, description: opts.description };
+    if (environment) body.environment = environment;
+    if (opts.tags) body.tags = splitList(opts.tags);
+    if (opts.timezone) body.settings = { timezone: opts.timezone };
+    printOutput(await client.request("PUT", `/v1/bases/${pathSegment(id)}`, body), outputFormat(this));
+  });
+  bases.command("update <id>").description(
+    "Update a base's mutable config (display name, description, tags, default timezone/settings). The id/slug is immutable."
+  ).option("--name <name>", "New display name").option("--description <desc>", "Description").option("--tags <tags>", "Comma-separated tags \u2014 replaces the existing tags").option(
+    "--timezone <tz>",
+    "Default IANA timezone for datetime canonicalization. Merges into existing settings."
+  ).option(
+    "--settings <json>",
+    "Raw settings JSON object (inline JSON or @file.json) \u2014 replaces the entire settings object"
+  ).option(
+    "--integrations <mode>",
+    "enabled | disabled. Preview-only: `disabled` neutralizes every external integration edge so the seeded preview behaves natively for production-safe agent evals"
+  ).action(async function(id, opts) {
+    const integrations = parseEnum("--integrations", opts.integrations, ["enabled", "disabled"]);
+    if (opts.name === void 0 && opts.description === void 0 && opts.tags === void 0 && opts.timezone === void 0 && opts.settings === void 0 && integrations === void 0) {
+      throw expected(
+        "Nothing to update. Provide at least one of --name, --description, --tags, --timezone, --settings, --integrations."
+      );
+    }
+    const client = await createDataClient();
+    const body = {};
+    if (opts.name !== void 0) body.name = opts.name;
+    if (opts.description !== void 0) body.description = opts.description;
+    if (opts.tags !== void 0) body.tags = splitList(opts.tags);
+    if (integrations !== void 0) body.integrations = integrations;
+    if (opts.settings !== void 0 || opts.timezone !== void 0) {
+      let settings;
+      if (opts.settings !== void 0) {
+        let parsed;
+        try {
+          parsed = parseData(opts.settings);
+        } catch (e) {
+          throw expected(`--settings: ${e instanceof Error ? e.message : "could not be read as JSON"}`);
+        }
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+          throw expected("--settings must be a valid JSON object");
+        }
+        settings = parsed;
+      } else {
+        const existing = await client.request("GET", `/v1/bases/${pathSegment(id)}`);
+        settings = { ...existing?.settings ?? {} };
+      }
+      if (opts.timezone !== void 0) settings.timezone = opts.timezone;
+      body.settings = settings;
+    }
+    printOutput(await client.request("PUT", `/v1/bases/${pathSegment(id)}`, body), outputFormat(this));
+  });
+  bases.command("rename <id>").description(
+    "Rename a base's display name (the id/slug is immutable \u2014 it scopes token grants, MCP endpoints, and references)"
+  ).requiredOption("--name <name>", "New display name").action(async function(id, opts) {
+    const client = await createDataClient();
+    printOutput(
+      await client.request("PUT", `/v1/bases/${pathSegment(id)}`, { name: opts.name }),
+      outputFormat(this)
+    );
+  });
+  bases.command("tag <id>").description("Set tags on a base").requiredOption("--tags <tags>", "Comma-separated tags (e.g. client:acme,billing)").action(async function(id, opts) {
+    const client = await createDataClient();
+    printOutput(
+      await client.request("PUT", `/v1/bases/${pathSegment(id)}`, { tags: splitList(opts.tags) }),
+      outputFormat(this)
+    );
+  });
+  bases.command("delete <id>").description(
+    "Delete a base. By default this is a tombstone: the base stops being listed, but its storage is retained and recreating the id restores it. Add --purge (preview bases only) to also reclaim the storage"
+  ).option("-y, --yes", "Skip confirmation prompt").option(
+    "--purge",
+    "Preview bases only. Permanently destroy the stored records, relationships, file metadata and config of this base instead of tombstoning it. The id is then retired and cannot be recreated"
+  ).action(async function(id, opts) {
+    const prompt3 = opts.purge ? `Purge base "${id}"? Its records, relationships, file metadata and config are destroyed permanently, and the id "${id}" is retired for good.` : `Delete base "${id}"? This cannot be undone.`;
+    if (!opts.yes && !await confirm(prompt3)) {
+      console.log("Aborted");
+      return;
+    }
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/bases/${pathSegment(id)}${opts.purge ? "?purge=true" : ""}`);
+    printOutput({ id, deleted: true, purged: opts.purge === true }, outputFormat(this));
+  });
+  bases.command("create-preview <origin-id>").description(
+    "Create a preview base by cloning the config of another base. The origin may be a production base or another preview; the new preview id is <origin-id>--<name>, linked to the origin it was cloned from (so a preview of a preview promotes through that origin, never straight to production)"
+  ).requiredOption("--name <name>", "Preview base name").option("--description <desc>", "Description").option(
+    "--integrations <mode>",
+    "enabled (default) | disabled. `disabled` makes this preview a seeded, production-safe agent-eval target: every external integration edge is inert and it behaves natively"
+  ).option(
+    "--create-only",
+    "Fail with 409 if the derived preview id already exists, instead of re-applying config onto it. Use for per-session ephemeral bases, where landing on a live sibling would corrupt both runs"
+  ).action(async function(originId, opts) {
+    const integrations = parseEnum("--integrations", opts.integrations, ["enabled", "disabled"]);
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/${pathSegment(originId, "origin base id")}/preview`, {
+        name: opts.name,
+        description: opts.description,
+        ...integrations !== void 0 ? { integrations } : {},
+        ...opts.createOnly ? { create_only: true } : {}
+      }),
+      outputFormat(this)
+    );
+  });
+  bases.command("list-previews <origin-id>").description("List preview bases cloned from a base (production or preview)").action(async function(originId) {
+    const client = await createDataClient();
+    const path31 = `/v1/${pathSegment(originId, "origin base id")}/previews`;
+    printOutput(
+      await client.collectPages((cursor) => pageOf(path31, cursor)),
+      outputFormat(this)
+    );
+  });
+  bases.command("promote <production-id>").description("Promote config from a preview base to production (human-only)").requiredOption("--from <preview-id>", "Source preview base id").option("--dry-run", "Show what would change without applying").option("--record-types <ids>", "Comma-separated record type ids to promote", splitList).option("--triggers <ids>", "Comma-separated trigger ids to promote", splitList).option("--inbound-webhooks <ids>", "Comma-separated inbound webhook ids to promote", splitList).action(async function(productionId, opts) {
+    const client = await createDataClient();
+    const data = await client.request("POST", `/v1/${pathSegment(productionId, "production base id")}/promote`, {
+      source_base_id: opts.from,
+      dry_run: opts.dryRun ?? false,
+      record_types: opts.recordTypes,
+      triggers: opts.triggers,
+      inbound_webhooks: opts.inboundWebhooks
+    });
+    printOutput(data, outputFormat(this));
+    const warnings = data?.source_credential_warnings ?? [];
+    if (warnings.length > 0) {
+      console.warn(
+        "\nExternal source credentials are NOT carried over by promotion \u2014 set these on production before the source will work:"
+      );
+      for (const w of warnings) console.warn(`  - ${sanitizeTerminalText(w.message)}`);
+    }
+  });
+  bases.command("rollback <production-id>").description("Roll back a promotion (human-only)").requiredOption("--promotion <promotion-id>", "Promotion id to roll back").action(async function(productionId, opts) {
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/${pathSegment(productionId, "production base id")}/promote/rollback`, {
+        promotion_id: opts.promotion
+      }),
+      outputFormat(this)
+    );
+  });
+  bases.command("promotions <production-id>").description("List promotion history for a production base").action(async function(productionId) {
+    const client = await createDataClient();
+    const path31 = `/v1/${pathSegment(productionId, "production base id")}/promotions`;
+    printOutput(
+      await client.collectPages((cursor) => pageOf(path31, cursor)),
+      outputFormat(this)
+    );
+  });
+  bases.command("use <base>").description(
+    "Bind this worktree to a base so push/pull refuse to run against a different one"
+  ).action(async function(selector) {
+    const baseId = resolveSelectorToBaseId(selector);
+    const previous = readBaseBinding();
+    if (previous !== baseId) {
+      try {
+        writeBaseBinding(baseId);
+      } catch (err) {
+        throw expected(err instanceof Error ? err.message : String(err));
+      }
+    }
+    if (outputFormat(this) === "json") {
+      printOutput({ base_id: baseId, previous_base_id: previous, changed: previous !== baseId }, "json");
+      return;
+    }
+    if (previous === baseId) {
+      console.log(`Worktree already bound to base ${baseId}.`);
+    } else {
+      console.log(
+        previous ? `Worktree rebound: ${previous} -> ${baseId}.` : `Worktree bound to base ${baseId}.`
+      );
+    }
+  });
+  bases.command("unbind").description("Clear the base binding for this worktree").action(async function() {
+    const previous = readBaseBinding();
+    if (previous) clearBaseBinding();
+    if (outputFormat(this) === "json") {
+      printOutput({ previous_base_id: previous, cleared: previous !== null }, "json");
+      return;
+    }
+    console.log(
+      previous ? `Worktree unbound from base (was: ${previous}).` : "No base binding to clear."
+    );
+  });
+  bases.addCommand(buildBasesTokensCommand());
+  bases.addCommand(buildBasesSecretsCommand());
+  bases.addCommand(buildBasesSqlCommand());
+  bases.addCommand(buildBasesImportCommand());
+  bases.addCommand(buildBasesBatchCommand());
+  bases.addCommand(buildBasesProvidersCommand());
+  bases.addCommand(buildBasesReportCommand());
+  return bases;
+}
+function resolveSelectorToBaseId(selector) {
+  const gitRoot = findGitRoot();
+  if (!gitRoot || selector.includes("/") || selector.includes(path30.sep)) return selector;
+  if (!isValidBaseId(selector)) return selector;
+  const metaPath = path30.join(resolveBasesDir(gitRoot), selector, BASE_META_FILE);
+  let meta;
+  try {
+    meta = yaml9.load(fs24.readFileSync(metaPath, "utf-8"));
+  } catch {
+    return selector;
+  }
+  const id = meta?.[BASE_ID_FIELD];
+  return typeof id === "string" && isValidBaseId(id) ? id : selector;
+}
+var BASE_META_FILE, BASE_ID_FIELD;
+var init_bases = __esm({
+  "src/data/commands/bases.ts"() {
+    "use strict";
+    init_batch();
+    init_import();
+    init_providers();
+    init_report2();
+    init_secrets();
+    init_sql();
+    init_tokens();
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+    init_terminal_output();
+    init_workspace();
+    init_layout();
+    init_base_binding();
+    init_base_id();
+    init_expected();
+    BASE_META_FILE = "base.yaml";
+    BASE_ID_FIELD = "base_id";
+  }
+});
+
+// src/data/commands/file-types.ts
+import { Command as Command11 } from "commander";
+function buildFileTypesCommand() {
+  const fileTypes = new Command11("file-types").description(
+    "Manage file types (Buckets) \u2014 storage policy + optional metadata schema for files"
+  );
+  fileTypes.command("list").description("List all file types in a base").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/file-types`), outputFormat(this));
+  });
+  fileTypes.command("get <id>").description("Get a file type").action(async function(id) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/file-types/${pathSegment(id, "file_type")}`), outputFormat(this));
+  });
+  fileTypes.command("upsert <id>").description("Create or update a file type (preview bases only)").requiredOption("--name <name>", "File type name").option("--description <desc>", "Description").option("--max-size <bytes>", "Max bytes per file (0 = unlimited)").option(
+    "--allowed-content-types <json>",
+    "Allowed content-types, JSON array (inline or @filename)"
+  ).option("--metadata-schema <json>", "JSON Schema for file metadata (inline JSON or @filename)").action(async function(id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const body = { name: opts.name };
+    if (opts.description) body.description = opts.description;
+    if (opts.maxSize !== void 0) body.max_size = parseByteCount("--max-size", opts.maxSize);
+    if (opts.allowedContentTypes) {
+      body.allowed_content_types = parseData(opts.allowedContentTypes);
+    }
+    if (opts.metadataSchema) body.metadata_schema = parseData(opts.metadataSchema);
+    printOutput(
+      await client.request("PUT", `/v1/${base}/file-types/${pathSegment(id, "file_type")}`, body),
+      outputFormat(this)
+    );
+  });
+  fileTypes.command("delete <id>").description("Delete a file type (cascades its files)").option("-y, --yes", "Skip confirmation prompt").action(async function(id, opts) {
+    if (!opts.yes && !await confirm(
+      `Delete file type "${id}"? This cascades its files and cannot be undone.`
+    )) {
+      console.log("Aborted");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/${base}/file-types/${pathSegment(id, "file_type")}`);
+    console.log("Deleted");
+  });
+  return fileTypes;
+}
+var init_file_types = __esm({
+  "src/data/commands/file-types.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+  }
+});
+
+// src/data/commands/files.ts
+import { Command as Command12 } from "commander";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync16 } from "fs";
+import { basename as basename14 } from "path";
+function renderFileDiff(fileType, filePath, from, to, d) {
+  console.log(sanitizeTerminalText(`${fileType}/${filePath}: v${from} \u2192 v${to}`));
+  const md = d.metadata_delta;
+  if (md) {
+    for (const f of ["path", "size", "content_type", "label"]) {
+      const change = md[f];
+      if (change) console.log(sanitizeTerminalText(`  ${f}: ${JSON.stringify(change.from)} \u2192 ${JSON.stringify(change.to)}`));
+    }
+    const meta = md.metadata;
+    for (const [k, v] of Object.entries(meta?.added ?? {})) {
+      console.log(sanitizeTerminalText(`  metadata + ${k}: ${JSON.stringify(v)}`));
+    }
+    for (const k of Object.keys(meta?.removed ?? {})) console.log(sanitizeTerminalText(`  metadata - ${k}`));
+    for (const [k, v] of Object.entries(meta?.changed ?? {})) {
+      console.log(sanitizeTerminalText(`  metadata ~ ${k}: ${JSON.stringify(v.from)} \u2192 ${JSON.stringify(v.to)}`));
+    }
+  }
+  const content = d.content;
+  if (!content?.changed) {
+    console.log("  content: unchanged");
+    return;
+  }
+  if (content.kind === "text" && content.lines) {
+    console.log("");
+    for (const l of content.lines) console.log(sanitizeTerminalText(`${l.op} ${l.text}`));
+  } else {
+    console.log(sanitizeTerminalText(`  content: changed (${content.kind})`));
+  }
+}
+function downloadTarget(remotePath, to) {
+  if (to) return to;
+  const derived = basename14(remotePath);
+  if (derived === "" || derived === "." || derived === "..") {
+    throw expected(
+      `Cannot derive a local filename from "${remotePath}" \u2014 pass --to <local> to name it.`
+    );
+  }
+  return derived;
+}
+function buildFilesCommand() {
+  const files = new Command12("files").description(
+    "Manage files (path-addressed, versioned content) within a file type"
+  );
+  files.command("put <file_type> <path>").description(
+    "Upload a local file to a path (e.g. wayai files put reports q3/summary.pdf --file ./summary.pdf)"
+  ).requiredOption("--file <local>", "Local file to upload").option("--content-type <type>", "MIME type", "application/octet-stream").action(async function(fileType, filePath, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const body = readFileSync25(opts.file);
+    const client = await createDataClient();
+    printOutput(
+      await client.upload(
+        `/v1/${base}/files/${pathSegment(fileType, "file_type")}/${pathSegments(filePath)}`,
+        body,
+        opts.contentType
+      ),
+      outputFormat(this)
+    );
+  });
+  files.command("get <file_type> <path>").description(
+    "Download a file (or --meta for metadata only). --version N reads a specific retained content version."
+  ).option("--to <local>", "Local file to save to (defaults to the file basename)").option("--meta", "Print metadata JSON instead of downloading the content").option("--version <n>", "Read a specific content version (default: latest)").action(async function(fileType, filePath, opts) {
+    const encoded = pathSegments(filePath);
+    const versionQs = opts.version !== void 0 ? `version=${encodeURIComponent(opts.version)}` : "";
+    const base = pathSegment(requireBase(this), "--base");
+    if (opts.meta) {
+      const qs = ["meta=1", versionQs].filter(Boolean).join("&");
+      const client2 = await createDataClient();
+      printOutput(
+        await client2.request("GET", `/v1/${base}/files/${pathSegment(fileType, "file_type")}/${encoded}?${qs}`),
+        outputFormat(this)
+      );
+      return;
+    }
+    const out = downloadTarget(filePath, opts.to);
+    const client = await createDataClient();
+    const { bytes } = await client.download(
+      `/v1/${base}/files/${pathSegment(fileType, "file_type")}/${encoded}${versionQs ? `?${versionQs}` : ""}`
+    );
+    writeFileSync16(out, bytes);
+    console.log(`Downloaded to ${out}`);
+  });
+  files.command("history <file_type> <path>").description("List the content versions of a file (newest first)").option("--limit <n>", "Max versions to return").option("--offset <n>", "Pagination offset").action(async function(fileType, filePath, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const qs = new URLSearchParams({ history: "1" });
+    if (opts.limit) qs.set("limit", opts.limit);
+    if (opts.offset) qs.set("offset", opts.offset);
+    printOutput(
+      await client.request(
+        "GET",
+        `/v1/${base}/files/${pathSegment(fileType, "file_type")}/${pathSegments(filePath)}?${qs}`
+      ),
+      outputFormat(this)
+    );
+  });
+  files.command("diff <file_type> <path>").description("Diff two content versions of a file \u2014 metadata delta plus a text content diff").requiredOption("--from <n>", "Base version number").requiredOption("--to <n>", "Target version number").action(async function(fileType, filePath, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const qs = new URLSearchParams({ diff: "1", from: opts.from, to: opts.to });
+    const data = await client.request(
+      "GET",
+      `/v1/${base}/files/${pathSegment(fileType, "file_type")}/${pathSegments(filePath)}?${qs}`
+    );
+    if (outputFormat(this) === "json") {
+      printOutput(data, "json");
+      return;
+    }
+    renderFileDiff(fileType, filePath, opts.from, opts.to, data);
+  });
+  files.command("list <file_type>").description("List files by path prefix").option("--prefix <path>", "Path prefix filter (e.g. q3/)").option("--depth <n>", "Max folder depth below the prefix (1 = immediate children)").option("--limit <n>", "Max results").option("--offset <n>", "Pagination offset").action(async function(fileType, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const qs = new URLSearchParams();
+    if (opts.prefix) qs.set("prefix", opts.prefix);
+    if (opts.depth) qs.set("depth", opts.depth);
+    if (opts.limit) qs.set("limit", opts.limit);
+    if (opts.offset) qs.set("offset", opts.offset);
+    const q = qs.toString();
+    printOutput(
+      await client.request("GET", `/v1/${base}/files/${pathSegment(fileType, "file_type")}${q ? `?${q}` : ""}`),
+      outputFormat(this)
+    );
+  });
+  files.command("mv <file_type> <from> <to>").description("Rename/move a file (the blob is untouched)").action(async function(fileType, from, to) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("PATCH", `/v1/${base}/files/${pathSegment(fileType, "file_type")}/${pathSegments(from)}`, {
+        new_path: to
+      }),
+      outputFormat(this)
+    );
+  });
+  files.command("rm <file_type> <path>").description("Delete a file").option("-y, --yes", "Skip confirmation prompt").action(async function(fileType, filePath, opts) {
+    if (!opts.yes && !await confirm(`Delete file "${fileType}/${filePath}"? This cannot be undone.`)) {
+      console.log("Aborted");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/${base}/files/${pathSegment(fileType, "file_type")}/${pathSegments(filePath)}`);
+    console.log("Deleted");
+  });
+  files.command("mount <file_type>").description(
+    "Mint an S3 credential so any harness can mount this file type as a filesystem (s3fs, cloud mount SDKs). Read-only by default; the secret is shown once."
+  ).option("--expires-in <seconds>", "Credential lifetime in seconds (default 30 days, max 90)").option(
+    "--mode <mode>",
+    "read_only (default) or read_write \u2014 the whole-bucket mode when no --path is given"
+  ).option(
+    "--path <prefix>",
+    "Confine to a path prefix (repeatable); optionally suffix :read_only|:read_write per prefix (e.g. drafts/:read_write)",
+    (v, acc) => {
+      acc.push(v);
+      return acc;
+    },
+    []
+  ).action(async function(fileType, opts) {
+    const body = { file_type: fileType };
+    if (opts.mode) {
+      if (opts.mode !== "read_only" && opts.mode !== "read_write") {
+        throw expected("--mode must be 'read_only' or 'read_write'.");
+      }
+      body.mode = opts.mode;
+    }
+    if (opts.path.length > 0) {
+      body.paths = opts.path.map((p) => {
+        const m = /^(.*):(read_only|read_write)$/.exec(p);
+        return m ? { prefix: m[1], mode: m[2] } : { prefix: p, mode: opts.mode ?? "read_only" };
+      });
+    }
+    if (opts.expiresIn !== void 0) {
+      const n = Number(opts.expiresIn);
+      if (!Number.isFinite(n)) {
+        throw expected("--expires-in must be a number of seconds.");
+      }
+      body.expires_in = n;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/${base}/s3-credentials`, body),
+      outputFormat(this)
+    );
+  });
+  return files;
+}
+var init_files = __esm({
+  "src/data/commands/files.ts"() {
+    "use strict";
+    init_expected();
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+    init_terminal_output();
+  }
+});
+
+// src/data/commands/inbound-webhooks.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { Command as Command13 } from "commander";
+function buildInboundWebhooksCommand() {
+  const inboundWebhooks = new Command13("inbound-webhooks").description(
+    "Manage inbound webhook endpoints"
+  );
+  inboundWebhooks.command("create").description("Create a new inbound webhook").requiredOption("--name <name>", "Inbound webhook name").option("--secret-stdin", "Read the HMAC shared secret from stdin (recommended for CI)").option("--id <id>", "Inbound webhook ID (auto-generated if omitted)").option("--record-type-scope <record_types>", "Comma-separated record_type scope").option(
+    "--field-mapping <json>",
+    'Inline mapping applied to the payload before write \u2014 a field_mapping JSON, e.g. {"to_external":{"status":"state"}} (to_external renames auto-invert on read); an explicit inbound-rename block and {"computed":{...}} are also accepted. Mutually exclusive with --source-binding.'
+  ).option(
+    "--source-binding <json>",
+    `Reuse a record_type source's field_mapping for the inbound translation \u2014 {"record_type":"<id>","source":"<name>"}. Mutually exclusive with --field-mapping.`
+  ).option(
+    "--ingest-auth <json>",
+    'Inbound auth scheme. Default (omitted) = HMAC signature. Static-header senders: {"type":"static_header","header":"X-Account-Key"} \u2014 the configured header is compared to the shared secret (constant-time) instead of an HMAC.'
+  ).option(
+    "--hydration <json>",
+    `Make this a reference-style ("notification + fetch") webhook: a thin delivery names a record id; the base fetches the full record via the bound source's read endpoint and stores it. Requires --source-binding and a single native --record-type-scope. JSON: {"id_path":"record_id","event_path":"event","event_map":{"ResourceDeleted":"delete"},"default_op":"upsert","merge":true}. Set "merge":true to refresh only the mapped (upstream-owned) fields on re-sync and preserve the locally-owned fields (status/tags/scores) on the same record.`
+  ).action(async function(opts) {
+    const secret = await readSecret(
+      {
+        stdin: opts.secretStdin,
+        // No prompt flag here — the prompt is this command's default.
+        prompt: void 0,
+        stdinFlag: "--secret-stdin",
+        promptHint: "omit --secret-stdin to be prompted"
+      },
+      "HMAC shared secret"
+    );
+    const body = {
+      name: opts.name,
+      secret,
+      enabled: true
+    };
+    if (opts.recordTypeScope) body.record_type_scope = splitList(opts.recordTypeScope);
+    if (opts.fieldMapping) body.field_mapping = parseData(opts.fieldMapping);
+    if (opts.sourceBinding) body.source_binding = parseData(opts.sourceBinding);
+    if (opts.ingestAuth) body.ingest_auth = parseData(opts.ingestAuth);
+    if (opts.hydration) body.hydration = parseData(opts.hydration);
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const inboundWebhookId = opts.id ?? randomUUID2();
+    printOutput(
+      await client.request(
+        "PUT",
+        `/v1/${base}/inbound-webhooks/${pathSegment(inboundWebhookId, "--id")}`,
+        body
+      ),
+      outputFormat(this)
+    );
+  });
+  inboundWebhooks.command("get <id>").description("Get an inbound webhook").action(async function(id) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("GET", `/v1/${base}/inbound-webhooks/${pathSegment(id, "inbound webhook id")}`),
+      outputFormat(this)
+    );
+  });
+  inboundWebhooks.command("list").description("List all inbound webhooks").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/inbound-webhooks`), outputFormat(this));
+  });
+  inboundWebhooks.command("deliveries").description(
+    'List hydration delivery status for reference-style ("notification + fetch") webhooks'
+  ).option("--status <status>", "Filter by status (pending|delivered|failed|dead)").option("--inbound-webhook <id>", "Filter to one inbound webhook").action(async function(opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const params = new URLSearchParams();
+    if (opts.status) params.set("status", opts.status);
+    if (opts.inboundWebhook) params.set("inbound_webhook_id", opts.inboundWebhook);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    printOutput(
+      await client.request("GET", `/v1/${base}/inbound-webhooks/deliveries${qs}`),
+      outputFormat(this)
+    );
+  });
+  inboundWebhooks.command("delete <id>").description("Delete an inbound webhook").option("-y, --yes", "Skip confirmation prompt").action(async function(id, opts) {
+    if (!opts.yes && !await confirm(`Delete inbound webhook ${id}? This cannot be undone.`)) {
+      console.log("Aborted");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/${base}/inbound-webhooks/${pathSegment(id, "inbound webhook id")}`);
+    console.log("Deleted");
+  });
+  return inboundWebhooks;
+}
+var init_inbound_webhooks = __esm({
+  "src/data/commands/inbound-webhooks.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+  }
+});
+
+// src/data/commands/query-relationships.ts
+import { Command as Command14 } from "commander";
+function buildQueryRelationshipsCommand() {
+  return new Command14("query-relationships").description("Query related records").argument("<record_type>", "RecordType of the source record").argument("<id>", "Source record ID").option("--type <type>", "Filter by relationship type").option("--direction <dir>", "Direction: outgoing, incoming, or both", "both").option("--limit <n>", "Max results", "50").option("--offset <n>", "Skip results", "0").action(async function(recordType2, id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const params = new URLSearchParams();
+    if (opts.type) params.set("rel_type", opts.type);
+    params.set("direction", DIRECTIONS[opts.direction] ?? opts.direction);
+    params.set("limit", opts.limit);
+    params.set("offset", opts.offset);
+    printOutput(
+      await client.request(
+        "GET",
+        `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${pathSegment(id, "record id")}/related?${params.toString()}`
+      ),
+      outputFormat(this)
+    );
+  });
+}
+var DIRECTIONS;
+var init_query_relationships = __esm({
+  "src/data/commands/query-relationships.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    DIRECTIONS = {
+      outgoing: "source",
+      incoming: "target",
+      both: "both"
+    };
+  }
+});
+
+// src/data/commands/record-types.ts
+import { Command as Command15 } from "commander";
+function buildRecordTypesCommand() {
+  const recordTypes = new Command15("record-types").description("Manage record_types");
+  recordTypes.command("list").description("List all record_types in a base").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/record-types`), outputFormat(this));
+  });
+  recordTypes.command("get <id>").description("Get a record_type").action(async function(id) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/record-types/${pathSegment(id, "record_type")}`), outputFormat(this));
+  });
+  recordTypes.command("upsert <id>").description("Create or update a record_type").requiredOption("--name <name>", "RecordType name").option("--description <desc>", "Description").option("--schema <json>", "JSON Schema (inline JSON or @filename)").option("--icon <icon>", "Icon name").option("--color <color>", "Hex color").option("--sources <json>", "External sources config (inline JSON or @filename)").action(async function(id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const body = { name: opts.name };
+    if (opts.description) body.description = opts.description;
+    if (opts.schema) body.json_schema = parseData(opts.schema);
+    if (opts.icon) body.icon = opts.icon;
+    if (opts.color) body.color = opts.color;
+    if (opts.sources) body.sources = parseData(opts.sources);
+    printOutput(
+      await client.request("PUT", `/v1/${base}/record-types/${pathSegment(id, "record_type")}`, body),
+      outputFormat(this)
+    );
+  });
+  recordTypes.command("delete <id>").description("Delete a record_type").option("-y, --yes", "Skip confirmation prompt").action(async function(id, opts) {
+    if (!opts.yes && !await confirm(`Delete record_type "${id}"? This cannot be undone.`)) {
+      console.log("Aborted");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/${base}/record-types/${pathSegment(id, "record_type")}`);
+    console.log("Deleted");
+  });
+  recordTypes.command("history <id>").description(
+    "View the change history (audit log) for a record_type \u2014 every schema/config version, who changed it, and when"
+  ).option("--limit <n>", "Max results").option("--offset <n>", "Pagination offset").option("--diff", "Include field-level diffs between versions").action(async function(id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("GET", `/v1/${base}/audit/record-types/${pathSegment(id, "record_type")}${historyQuery(opts)}`),
+      outputFormat(this)
+    );
+  });
+  return recordTypes;
+}
+var init_record_types = __esm({
+  "src/data/commands/record-types.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+  }
+});
+
+// src/data/commands/records.ts
+import { Command as Command16 } from "commander";
+function recordKey(id, externalSource) {
+  return externalSource ? foreignSegment(id, "external id") : pathSegment(id, "record id");
+}
+function buildRecordsCommand() {
+  const records = new Command16("records").description("Manage records");
+  records.command("upsert <record_type>").description("Create or update a record").requiredOption("--data <json>", "Record data (inline JSON or @filename)").option("--id <id>", "Internal record ID (UUID) to update a known record").option("--external-id <id>", "External/agent-supplied ID for idempotent upsert").option("--external-source <source>", "Source system for external_id (e.g. stripe)").action(async function(recordType2, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const body = { data: parseData(opts.data) };
+    if (opts.externalId) body.external_id = opts.externalId;
+    if (opts.externalSource) body.external_source = opts.externalSource;
+    const path31 = opts.id ? `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${pathSegment(opts.id, "--id")}` : `/v1/${base}/records/${pathSegment(recordType2, "record_type")}`;
+    printOutput(await client.request("PUT", path31, body), outputFormat(this));
+  });
+  records.command("query <record_type>").description("List/search records: exact filters + fuzzy `search`, sorting, pagination").option(
+    "--external-source <source>",
+    "List from an external source (proxy-backed record_type). Combine with --filter when the source forwards filters."
+  ).option(
+    "--filter <json>",
+    "Filter DSL expression (inline JSON or @filename). Use the `search` operator for fuzzy matching."
+  ).option(
+    "--sort <json>",
+    'Sort expressions (inline JSON or @filename), e.g. [{"field":"data.created","direction":"desc"}]'
+  ).option("--fields <list>", "Comma-separated field projection").option("--limit <n>", "Max results").option("--offset <n>", "Pagination offset").action(async function(recordType2, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const qs = new URLSearchParams();
+    if (opts.externalSource) qs.set("external_source", opts.externalSource);
+    if (opts.filter) qs.set("filter", JSON.stringify(parseData(opts.filter)));
+    if (opts.sort) qs.set("sort", JSON.stringify(parseData(opts.sort)));
+    if (opts.fields) qs.set("fields", opts.fields);
+    if (opts.limit) qs.set("limit", opts.limit);
+    if (opts.offset) qs.set("offset", opts.offset);
+    const q = qs.toString();
+    printOutput(
+      await client.request("GET", `/v1/${base}/records/${pathSegment(recordType2, "record_type")}${q ? `?${q}` : ""}`),
+      outputFormat(this)
+    );
+  });
+  records.command("get <record_type> <id>").description(
+    "Get a record by internal ID, or by external_id (pass --external-source to scope it)"
+  ).option(
+    "--external-source <source>",
+    "Treat <id> as an external_id scoped to this source system (e.g. stripe)"
+  ).action(async function(recordType2, id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    let path31 = `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${recordKey(id, opts.externalSource)}`;
+    if (opts.externalSource) path31 += `?external_source=${encodeURIComponent(opts.externalSource)}`;
+    printOutput(await client.request("GET", path31), outputFormat(this));
+  });
+  records.command("delete <record_type> <id>").description(
+    "Delete a record by internal ID, or by external_id (pass --external-source to scope it)"
+  ).option("-y, --yes", "Skip confirmation prompt").option(
+    "--external-source <source>",
+    "Treat <id> as an external_id scoped to this source system (e.g. stripe)"
+  ).action(async function(recordType2, id, opts) {
+    if (!opts.yes && !await confirm(`Delete record ${recordType2}/${id}? This cannot be undone.`)) {
+      console.log("Aborted");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    let path31 = `/v1/${base}/records/${pathSegment(recordType2, "record_type")}/${recordKey(id, opts.externalSource)}`;
+    if (opts.externalSource) {
+      path31 += `?external_source=${encodeURIComponent(opts.externalSource)}&external_id=${encodeURIComponent(id)}`;
+    }
+    await client.request("DELETE", path31);
+    console.log("Deleted");
+  });
+  records.command("history <id>").description(
+    "View the change history (audit log) for a record \u2014 every version, who changed it, and when"
+  ).option("--limit <n>", "Max results").option("--offset <n>", "Pagination offset").option("--diff", "Include field-level diffs between versions").action(async function(id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("GET", `/v1/${base}/audit/records/${pathSegment(id, "record id")}${historyQuery(opts)}`),
+      outputFormat(this)
+    );
+  });
+  return records;
+}
+var init_records = __esm({
+  "src/data/commands/records.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+  }
+});
+
+// src/data/commands/relationship-types.ts
+import { Command as Command17 } from "commander";
+function buildRelationshipTypesCommand() {
+  const relationshipTypes = new Command17("relationship-types").description(
+    "Manage relationship types (the schema for a relationship's metadata)"
+  );
+  relationshipTypes.command("list").description("List all relationship types in a base").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("GET", `/v1/${base}/relationship-types`),
+      outputFormat(this)
+    );
   });
-  bases.command("rename <id>").description(
-    "Rename a base's display name (the id/slug is immutable \u2014 it scopes token grants, MCP endpoints, and references)"
-  ).requiredOption("--name <name>", "New display name").action(async function(id, opts) {
+  relationshipTypes.command("get <rel_type>").description("Get a relationship type").action(async function(relType) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
     printOutput(
-      await client.request("PUT", `/v1/bases/${pathSegment(id)}`, { name: opts.name }),
+      await client.request("GET", `/v1/${base}/relationship-types/${pathSegment(relType, "rel_type")}`),
       outputFormat(this)
     );
   });
-  bases.command("tag <id>").description("Set tags on a base").requiredOption("--tags <tags>", "Comma-separated tags (e.g. client:acme,billing)").action(async function(id, opts) {
+  relationshipTypes.command("upsert <rel_type>").description("Create or update a relationship type").option("--description <desc>", "Description").option(
+    "--schema <json>",
+    "JSON Schema for the relationship data (inline JSON or @filename). Omit to allow any data."
+  ).option(
+    "--source-record-types <json>",
+    "JSON array of allowed source record_types (inline JSON or @filename)"
+  ).option(
+    "--target-record-types <json>",
+    "JSON array of allowed target record_types (inline JSON or @filename)"
+  ).action(async function(relType, opts) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
+    const body = {};
+    if (opts.description) body.description = opts.description;
+    if (opts.schema) body.data_schema = parseData(opts.schema);
+    if (opts.sourceRecordTypes) body.source_record_types = parseData(opts.sourceRecordTypes);
+    if (opts.targetRecordTypes) body.target_record_types = parseData(opts.targetRecordTypes);
     printOutput(
-      await client.request("PUT", `/v1/bases/${pathSegment(id)}`, { tags: splitList(opts.tags) }),
+      await client.request("PUT", `/v1/${base}/relationship-types/${pathSegment(relType, "rel_type")}`, body),
       outputFormat(this)
     );
   });
-  bases.command("delete <id>").description(
-    "Delete a base. By default this is a tombstone: the base stops being listed, but its storage is retained and recreating the id restores it. Add --purge (preview bases only) to also reclaim the storage"
-  ).option("-y, --yes", "Skip confirmation prompt").option(
-    "--purge",
-    "Preview bases only. Permanently destroy the stored records, relationships, file metadata and config of this base instead of tombstoning it. The id is then retired and cannot be recreated"
-  ).action(async function(id, opts) {
-    const prompt3 = opts.purge ? `Purge base "${id}"? Its records, relationships, file metadata and config are destroyed permanently, and the id "${id}" is retired for good.` : `Delete base "${id}"? This cannot be undone.`;
-    if (!opts.yes && !await confirm(prompt3)) {
+  relationshipTypes.command("delete <rel_type>").description("Delete a relationship type").option("-y, --yes", "Skip confirmation prompt").action(async function(relType, opts) {
+    if (!opts.yes && !await confirm(`Delete relationship type "${relType}"? This cannot be undone.`)) {
       console.log("Aborted");
       return;
     }
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
-    await client.request("DELETE", `/v1/bases/${pathSegment(id)}${opts.purge ? "?purge=true" : ""}`);
-    printOutput({ id, deleted: true, purged: opts.purge === true }, outputFormat(this));
+    await client.request("DELETE", `/v1/${base}/relationship-types/${pathSegment(relType, "rel_type")}`);
+    console.log("Deleted");
   });
-  bases.command("create-preview <origin-id>").description(
-    "Create a preview base by cloning the config of another base. The origin may be a production base or another preview; the new preview id is <origin-id>--<name>, linked to the origin it was cloned from (so a preview of a preview promotes through that origin, never straight to production)"
-  ).requiredOption("--name <name>", "Preview base name").option("--description <desc>", "Description").option(
-    "--integrations <mode>",
-    "enabled (default) | disabled. `disabled` makes this preview a seeded, production-safe agent-eval target: every external integration edge is inert and it behaves natively"
+  relationshipTypes.command("history <id>").description(
+    "View the change history (audit log) for a relationship type \u2014 every config version, who changed it, and when"
+  ).option("--limit <n>", "Max results").option("--offset <n>", "Pagination offset").option("--diff", "Include field-level diffs between versions").action(async function(id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request(
+        "GET",
+        `/v1/${base}/audit/relationship-types/${pathSegment(id, "rel_type")}${historyQuery(opts)}`
+      ),
+      outputFormat(this)
+    );
+  });
+  return relationshipTypes;
+}
+var init_relationship_types = __esm({
+  "src/data/commands/relationship-types.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+  }
+});
+
+// src/data/commands/relationships.ts
+import { Command as Command18 } from "commander";
+function relationshipKey(id, relType) {
+  return relType ? foreignSegment(id, "external id") : pathSegment(id, "relationship id");
+}
+function endpointBodyFields(role, byId, byExternal, externalSource) {
+  if ((byId ? 1 : 0) + (byExternal ? 1 : 0) !== 1) {
+    throw expected(`Provide exactly one of --${role} or --${role}-external.`);
+  }
+  const ref = byId ?? byExternal;
+  const segments = ref.split("/");
+  const [recordType2, key] = segments;
+  if (segments.length !== 2 || !recordType2 || !key) {
+    throw expected(
+      `--${role}${byId ? "" : "-external"} must be <record_type/${byId ? "id" : "external_id"}>, got '${ref}'.`
+    );
+  }
+  if (externalSource && !byExternal) {
+    throw expected(`--${role}-external-source requires --${role}-external.`);
+  }
+  const fields = { [`${role}_record_type`]: recordType2 };
+  if (byId) {
+    fields[`${role}_id`] = key;
+  } else {
+    fields[`${role}_external_id`] = key;
+    if (externalSource) fields[`${role}_external_source`] = externalSource;
+  }
+  return fields;
+}
+function byKeyQuery(relType, externalSource) {
+  const qs = new URLSearchParams();
+  if (relType) qs.set("rel_type", relType);
+  if (externalSource) qs.set("external_source", externalSource);
+  const q = qs.toString();
+  return q ? `?${q}` : "";
+}
+function buildRelationshipsCommand() {
+  const relationships = new Command18("relationships").description(
+    "Manage relationships between records"
+  );
+  relationships.command("upsert").description("Create or update a relationship").option("--source <record_type/id>", "Source record by internal id").option(
+    "--source-external <record_type/external_id>",
+    "Source record by external_id (the record must exist)"
+  ).option("--source-external-source <name>", "Source system scoping --source-external").option("--target <record_type/id>", "Target record by internal id").option(
+    "--target-external <record_type/external_id>",
+    "Target record by external_id (the record must exist)"
+  ).option("--target-external-source <name>", "Source system scoping --target-external").requiredOption("--type <type>", "Relationship type").option("--id <id>", "Relationship ID").option(
+    "--external-id <key>",
+    "The relationship's own external key: a retried upsert with the same key updates the first row instead of duplicating it"
+  ).option("--external-source <name>", "Source system scoping the relationship's --external-id").option("--data <json>", "Relationship metadata (inline JSON or @filename)").action(async function(opts) {
+    const body = {
+      rel_type: opts.type,
+      ...endpointBodyFields("source", opts.source, opts.sourceExternal, opts.sourceExternalSource),
+      ...endpointBodyFields("target", opts.target, opts.targetExternal, opts.targetExternalSource)
+    };
+    if (opts.id) body.id = opts.id;
+    if (opts.externalId) body.external_id = opts.externalId;
+    if (opts.externalSource) body.external_source = opts.externalSource;
+    if (opts.data) body.data = parseData(opts.data);
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const path31 = opts.id ? `/v1/${base}/relationships/${pathSegment(opts.id, "--id")}` : `/v1/${base}/relationships`;
+    printOutput(await client.request("PUT", path31, body), outputFormat(this));
+  });
+  relationships.command("get <id>").description(
+    "Get a relationship by ID (or by its external key: pass the external_id with --rel-type)"
   ).option(
-    "--create-only",
-    "Fail with 409 if the derived preview id already exists, instead of re-applying config onto it. Use for per-session ephemeral bases, where landing on a live sibling would corrupt both runs"
-  ).action(async function(originId, opts) {
-    const integrations = parseEnum("--integrations", opts.integrations, ["enabled", "disabled"]);
+    "--rel-type <type>",
+    "Treat <id> as the relationship external_id, scoped to this relationship type"
+  ).option("--external-source <name>", "Source system scoping the external_id (with --rel-type)").action(async function(id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
     printOutput(
-      await client.request("POST", `/v1/${pathSegment(originId, "origin base id")}/preview`, {
-        name: opts.name,
-        description: opts.description,
-        ...integrations !== void 0 ? { integrations } : {},
-        ...opts.createOnly ? { create_only: true } : {}
-      }),
+      await client.request(
+        "GET",
+        `/v1/${base}/relationships/${relationshipKey(id, opts.relType)}${byKeyQuery(opts.relType, opts.externalSource)}`
+      ),
       outputFormat(this)
     );
   });
-  bases.command("list-previews <origin-id>").description("List preview bases cloned from a base (production or preview)").action(async function(originId) {
+  relationships.command("delete <id>").description(
+    "Delete a relationship by ID (or by its external key: pass the external_id with --rel-type)"
+  ).option(
+    "--rel-type <type>",
+    "Treat <id> as the relationship external_id, scoped to this relationship type"
+  ).option("--external-source <name>", "Source system scoping the external_id (with --rel-type)").option("-y, --yes", "Skip confirmation prompt").action(async function(id, opts) {
+    if (!opts.yes && !await confirm(`Delete relationship ${id}? This cannot be undone.`)) {
+      console.log("Aborted");
+      return;
+    }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request(
+      "DELETE",
+      `/v1/${base}/relationships/${relationshipKey(id, opts.relType)}${byKeyQuery(opts.relType, opts.externalSource)}`
+    );
+    console.log("Deleted");
+  });
+  relationships.command("history <id>").description(
+    "View the change history (audit log) for a relationship \u2014 every version, who changed it, and when"
+  ).option("--limit <n>", "Max results").option("--offset <n>", "Pagination offset").option("--diff", "Include field-level diffs between versions").action(async function(id, opts) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
-    const path31 = `/v1/${pathSegment(originId, "origin base id")}/previews`;
     printOutput(
-      await client.collectPages((cursor) => pageOf(path31, cursor)),
+      await client.request("GET", `/v1/${base}/audit/relationships/${pathSegment(id, "relationship id")}${historyQuery(opts)}`),
       outputFormat(this)
     );
   });
-  bases.command("promote <production-id>").description("Promote config from a preview base to production (human-only)").requiredOption("--from <preview-id>", "Source preview base id").option("--dry-run", "Show what would change without applying").option("--record-types <ids>", "Comma-separated record type ids to promote", splitList).option("--triggers <ids>", "Comma-separated trigger ids to promote", splitList).option("--inbound-webhooks <ids>", "Comma-separated inbound webhook ids to promote", splitList).action(async function(productionId, opts) {
+  return relationships;
+}
+var init_relationships = __esm({
+  "src/data/commands/relationships.ts"() {
+    "use strict";
+    init_expected();
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+  }
+});
+
+// src/data/commands/seed.ts
+import { Command as Command19 } from "commander";
+function buildSeedCommand() {
+  const seed = new Command19("seed").description(
+    "Apply, reset, or clear a seed fixture on a preview base (hermetic eval data)"
+  );
+  seed.command("apply <name>").description(
+    "Idempotently upsert the fixture (keyed by external_id, so re-applying never twins). Preview-only."
+  ).action(async function(name) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
-    const data = await client.request("POST", `/v1/${pathSegment(productionId, "production base id")}/promote`, {
-      source_base_id: opts.from,
-      dry_run: opts.dryRun ?? false,
-      record_types: opts.recordTypes,
-      triggers: opts.triggers,
-      inbound_webhooks: opts.inboundWebhooks
-    });
-    printOutput(data, outputFormat(this));
-    const warnings = data?.source_credential_warnings ?? [];
-    if (warnings.length > 0) {
-      console.warn(
-        "\nExternal source credentials are NOT carried over by promotion \u2014 set these on production before the source will work:"
-      );
-      for (const w of warnings) console.warn(`  - ${sanitizeTerminalText(w.message)}`);
-    }
+    printOutput(
+      await client.request("POST", `/v1/${base}/seeds/${pathSegment(name, "fixture name")}/apply`),
+      outputFormat(this)
+    );
   });
-  bases.command("rollback <production-id>").description("Roll back a promotion (human-only)").requiredOption("--promotion <promotion-id>", "Promotion id to roll back").action(async function(productionId, opts) {
+  seed.command("reset <name>").description(
+    "Restore the declared baseline: re-apply in place (fixing trigger-mutated records) and prune owned rows the fixture no longer declares. Record types listed in exclusive_record_types are treated as authoritative \u2014 reset also removes their non-declared records (agent-created residue) and any relationships referencing them. Preview-only."
+  ).action(async function(name) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
     printOutput(
-      await client.request("POST", `/v1/${pathSegment(productionId, "production base id")}/promote/rollback`, {
-        promotion_id: opts.promotion
+      await client.request("POST", `/v1/${base}/seeds/${pathSegment(name, "fixture name")}/reset`),
+      outputFormat(this)
+    );
+  });
+  seed.command("clear <name>").description("Delete every row the fixture owns (teardown). Preview-only.").action(async function(name) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/${base}/seeds/${pathSegment(name, "fixture name")}/clear`),
+      outputFormat(this)
+    );
+  });
+  seed.command("list").description("List the seed fixtures defined on a base").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/seeds`), outputFormat(this));
+  });
+  seed.command("get <name>").description("Show a seed fixture definition (its declared records and relationships)").action(async function(name) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/seeds/${pathSegment(name, "fixture name")}`), outputFormat(this));
+  });
+  const lease = seed.command("lease").description("Coordinate an isolated fixture lease");
+  lease.command("acquire <fixture>").description("Reset a fixture and atomically acquire the preview base for one eval run").requiredOption("--lease-id <uuidv7>", "Client-generated UUIDv7 (permanently single-use)").requiredOption(
+    "--owner-ref <ref>",
+    "Safe ID: 1-200 letters/digits or ._:@/+~=- (descriptive only)"
+  ).action(async function(fixture, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/${base}/seed-leases/acquire`, {
+        lease_id: opts.leaseId,
+        fixture,
+        owner_ref: opts.ownerRef
       }),
       outputFormat(this)
     );
   });
-  bases.command("promotions <production-id>").description("List promotion history for a production base").action(async function(productionId) {
+  lease.command("status").description("Inspect your lease, or learn only whether another actor has locked the base").option("--lease-id <uuidv7>", "Inspect a specific lease ID").action(async function(opts) {
+    const base = pathSegment(requireBase(this), "--base");
     const client = await createDataClient();
-    const path31 = `/v1/${pathSegment(productionId, "production base id")}/promotions`;
+    const params = new URLSearchParams();
+    if (opts.leaseId !== void 0) params.set("lease_id", opts.leaseId);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
     printOutput(
-      await client.collectPages((cursor) => pageOf(path31, cursor)),
+      await client.request("GET", `/v1/${base}/seed-leases/status${query}`),
       outputFormat(this)
     );
   });
-  bases.command("use <base>").description(
-    "Bind this worktree to a base so push/pull refuse to run against a different one"
-  ).action(async function(selector) {
-    const baseId = resolveSelectorToBaseId(selector);
-    const previous = readBaseBinding();
-    if (previous !== baseId) {
-      try {
-        writeBaseBinding(baseId);
-      } catch (err) {
-        throw expected(err instanceof Error ? err.message : String(err));
+  lease.command("release <fixture>").description("Clear fixture-owned data and release the matching lease").requiredOption("--lease-id <uuidv7>", "The UUIDv7 used to acquire the lease").requiredOption("--owner-ref <ref>", "Same safe ID: 1-200 letters/digits or ._:@/+~=-").action(async function(fixture, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(
+      await client.request("POST", `/v1/${base}/seed-leases/release`, {
+        lease_id: opts.leaseId,
+        fixture,
+        owner_ref: opts.ownerRef
+      }),
+      outputFormat(this)
+    );
+  });
+  return seed;
+}
+var init_seed = __esm({
+  "src/data/commands/seed.ts"() {
+    "use strict";
+    init_client();
+    init_output();
+    init_helpers();
+  }
+});
+
+// src/data/commands/toolsets.ts
+import { Command as Command20 } from "commander";
+function collect(value, previous) {
+  return [...previous, value];
+}
+function parseSpec(spec) {
+  const [key, opsStr] = spec.split(":");
+  if (!key || !opsStr) {
+    throw expected(`Invalid spec '${spec}'. Expected format: name:op1,op2`);
+  }
+  return { key, ops: splitList(opsStr) };
+}
+function parseActionRef(spec) {
+  const [action, actionName] = spec.split("=");
+  if (!action) {
+    throw expected(`Invalid --action '${spec}'. Expected an Action id, or <action_id>=<surface_name>.`);
+  }
+  return actionName ? { action, action_name: actionName } : { action };
+}
+function parseRelSpec(spec) {
+  const { key, ops } = parseSpec(spec);
+  return { rel_type: key, operations: ops };
+}
+function buildToolsetsCommand() {
+  const toolsets = new Command20("toolsets").description("Manage MCP toolsets");
+  toolsets.command("upsert <slug>").description("Create or update an MCP toolset").option("--name <name>", "Toolset display name (required unless using --config)").option("--description <desc>", "Toolset description").option(
+    "--action <ref>",
+    "Reference an Action by id, optionally renamed: <action_id> or <action_id>=<surface_name> (repeatable). Create Actions first with `wayai actions upsert`.",
+    collect,
+    []
+  ).option("--relationship <spec>", "Relationship tool spec: rel_type:op1,op2 (repeatable)", collect, []).option("--batch <spec>", "Batch operation spec: record_type_or_rel:op1,op2 (repeatable)", collect, []).option("--sql-query", "Enable sql_query tool").option(
+    "--config <json>",
+    "Full toolset config as JSON. A toolset composes first-class Actions by reference \u2014 its `actions` are refs {action: <action_id>, action_name?, description_override?}. Create the Actions with `wayai actions upsert` (each carries its own record_type, operation, and guard/shaping config: filterable_fields, writable_fields, precondition, binding). Use @file.json to read from file."
+  ).option(
+    "--mint-token",
+    "After upsert, also mint a toolset-bound (consumer) token for this base and print it (handy for sandbox-testing the preview toolset)"
+  ).action(async function(slug, opts) {
+    let body;
+    if (opts.config) {
+      body = parseData(opts.config);
+    } else {
+      if (!opts.name) {
+        throw expected("--name is required (or use --config for full JSON config)");
+      }
+      body = { name: opts.name, actions: opts.action.map(parseActionRef) };
+      if (opts.description) body.description = opts.description;
+      if (opts.relationship.length > 0) {
+        body.relationships = opts.relationship.map(parseRelSpec);
+      }
+      if (opts.batch.length > 0) {
+        const operations = {};
+        for (const spec of opts.batch) {
+          const parsed = parseSpec(spec);
+          operations[parsed.key] = parsed.ops;
+        }
+        body.batch = { enabled: true, operations };
       }
+      if (opts.sqlQuery) body.sql_query = true;
     }
-    if (outputFormat(this) === "json") {
-      printOutput({ base_id: baseId, previous_base_id: previous, changed: previous !== baseId }, "json");
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const format = outputFormat(this);
+    printOutput(await client.request("PUT", `/v1/${base}/toolsets/${pathSegment(slug, "toolset slug")}`, body), format);
+    if (opts.mintToken) {
+      const tokenData = await client.request("POST", "/v1/tokens", {
+        name: `${slug} consumer`,
+        toolset_binding: { base_id: base, toolset_id: slug }
+      });
+      if (format === "json") {
+        printOutput(tokenData, format);
+      } else {
+        console.log("\nToolset-bound token:");
+        printOutput(tokenData, format);
+        console.log(`MCP URL: ${toolsetMcpUrl(slug)}`);
+      }
+    }
+  });
+  toolsets.command("get <slug>").description("Get a toolset").option("--resolved", "Include resolved record_type schemas").action(async function(slug, opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const path31 = opts.resolved ? `/v1/${base}/toolsets/${pathSegment(slug, "toolset slug")}/resolved` : `/v1/${base}/toolsets/${pathSegment(slug, "toolset slug")}`;
+    printOutput(await client.request("GET", path31), outputFormat(this));
+  });
+  toolsets.command("list").description("List all toolsets").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/toolsets`), outputFormat(this));
+  });
+  toolsets.command("delete <slug>").description("Delete a toolset").option("-y, --yes", "Skip confirmation prompt").action(async function(slug, opts) {
+    if (!opts.yes && !await confirm(`Delete toolset "${slug}"? This cannot be undone.`)) {
+      console.log("Aborted");
       return;
     }
-    if (previous === baseId) {
-      console.log(`Worktree already bound to base ${baseId}.`);
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/${base}/toolsets/${pathSegment(slug, "toolset slug")}`);
+    console.log("Deleted");
+  });
+  toolsets.command("url <slug>").description("Get the MCP connection URL for a toolset").action((slug) => {
+    console.log(toolsetMcpUrl(slug));
+  });
+  return toolsets;
+}
+var init_toolsets = __esm({
+  "src/data/commands/toolsets.ts"() {
+    "use strict";
+    init_expected();
+    init_client();
+    init_output();
+    init_helpers();
+    init_utils();
+  }
+});
+
+// src/data/commands/triggers.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { Command as Command21 } from "commander";
+function buildTriggersCommand() {
+  const triggers = new Command21("triggers").description(
+    "Manage triggers (outbound webhooks, internal writes, external writes)"
+  );
+  triggers.command("create").description(
+    "Create a trigger (a webhook, an internal_write that patches a referenced record, or an external_write that mirrors the record to an external source)"
+  ).requiredOption("--name <name>", "Trigger name").requiredOption("--events <events>", "Comma-separated event types").option("--url <url>", "Webhook target URL (webhook actions)").option("--secret-stdin", "Read the webhook HMAC signing secret from stdin (webhook actions)").option("--secret-prompt", "Prompt for the webhook HMAC signing secret, masked (webhook actions)").option(
+    "--action <json>",
+    `Action JSON. webhook {"type":"webhook","url":...,"secret":...}; internal_write {"type":"internal_write","target":"slots","match":{"source_field":"data.slot_id"},"patch":{"status":"busy"},"precondition":{"field":"data.status","op":"eq","value":"free"},"mode":"async"} (mode: "async" applies after the write, "transactional" applies atomically so a precondition miss rolls the write back); external_write {"type":"external_write","record_type":"upstream_appointments","source":"legacy","op":"create","watched_fields":"mapped"} (writes the triggering record through that source's write path \u2014 translation, endpoint, auth \u2014 and links the upstream-assigned id back as external_id; "record_type" defaults to the triggering record_type, "op" defaults from the event; "watched_fields" scopes UPDATE dispatch to writes that changed an upstream-mapped field \u2014 "mapped" = the source's to_external keys, or an explicit array of data fields \u2014 so an overlay-only write skips the redundant upstream push; omit to fire on every update)`
+  ).option("--id <id>", "Trigger ID (auto-generated if omitted)").option("--record-type-scope <record_types>", "Comma-separated record_type scope").option("--filter <json>", "Filter expression (JSON)").option(
+    "--skip-cascade-writes <bool>",
+    "Skip firing on cascade-originated (internal_write) writes (default true)"
+  ).action(async function(opts) {
+    if (!opts.action && !opts.url) {
+      throw expected("Provide --url (webhook) or --action <json> (e.g. an internal_write action).");
+    }
+    const body = {
+      name: opts.name,
+      events: splitList(opts.events),
+      enabled: true
+    };
+    if (opts.action) {
+      body.action = parseData(opts.action);
     } else {
-      console.log(
-        previous ? `Worktree rebound: ${previous} -> ${baseId}.` : `Worktree bound to base ${baseId}.`
-      );
+      body.url = opts.url;
+      if (opts.secretStdin || opts.secretPrompt) {
+        body.secret = await readSecret(
+          {
+            stdin: opts.secretStdin,
+            prompt: opts.secretPrompt,
+            stdinFlag: "--secret-stdin",
+            promptHint: "--secret-prompt"
+          },
+          "Webhook signing secret"
+        );
+      }
+    }
+    if (opts.recordTypeScope) body.record_type_scope = splitList(opts.recordTypeScope);
+    if (opts.filter) body.filter = parseData(opts.filter);
+    if (opts.skipCascadeWrites !== void 0) {
+      body.skip_cascade_writes = opts.skipCascadeWrites !== "false";
     }
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const triggerId = opts.id ?? randomUUID3();
+    printOutput(
+      await client.request("PUT", `/v1/${base}/triggers/${pathSegment(triggerId, "--id")}`, body),
+      outputFormat(this)
+    );
   });
-  bases.command("unbind").description("Clear the base binding for this worktree").action(async function() {
-    const previous = readBaseBinding();
-    if (previous) clearBaseBinding();
-    if (outputFormat(this) === "json") {
-      printOutput({ previous_base_id: previous, cleared: previous !== null }, "json");
+  triggers.command("get <id>").description("Get a trigger").action(async function(id) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/triggers/${pathSegment(id, "trigger id")}`), outputFormat(this));
+  });
+  triggers.command("list").description("List all triggers").action(async function() {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    printOutput(await client.request("GET", `/v1/${base}/triggers`), outputFormat(this));
+  });
+  triggers.command("deliveries").description("List trigger delivery attempts (status, retries, errors)").option("--status <status>", "Filter by status (pending | delivered | failed | dead)").option("--trigger-id <id>", "Filter by trigger id").action(async function(opts) {
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    const params = new URLSearchParams();
+    if (opts.status) params.set("status", opts.status);
+    if (opts.triggerId) params.set("trigger_id", opts.triggerId);
+    const qs = params.toString();
+    printOutput(
+      await client.request("GET", `/v1/${base}/triggers/deliveries${qs ? `?${qs}` : ""}`),
+      outputFormat(this)
+    );
+  });
+  triggers.command("delete <id>").description("Delete a trigger").option("-y, --yes", "Skip confirmation prompt").action(async function(id, opts) {
+    if (!opts.yes && !await confirm(`Delete trigger ${id}? This cannot be undone.`)) {
+      console.log("Aborted");
       return;
     }
-    console.log(
-      previous ? `Worktree unbound from base (was: ${previous}).` : "No base binding to clear."
-    );
+    const base = pathSegment(requireBase(this), "--base");
+    const client = await createDataClient();
+    await client.request("DELETE", `/v1/${base}/triggers/${pathSegment(id, "trigger id")}`);
+    console.log("Deleted");
   });
-  return bases;
-}
-function resolveSelectorToBaseId(selector) {
-  const gitRoot = findGitRoot();
-  if (!gitRoot || selector.includes("/") || selector.includes(path30.sep)) return selector;
-  if (!isValidBaseId(selector)) return selector;
-  const metaPath = path30.join(resolveBasesDir(gitRoot), selector, BASE_META_FILE);
-  let meta;
-  try {
-    meta = yaml9.load(fs24.readFileSync(metaPath, "utf-8"));
-  } catch {
-    return selector;
-  }
-  const id = meta?.[BASE_ID_FIELD];
-  return typeof id === "string" && isValidBaseId(id) ? id : selector;
+  return triggers;
 }
-var BASE_META_FILE, BASE_ID_FIELD;
-var init_bases = __esm({
-  "src/data/commands/bases.ts"() {
+var init_triggers = __esm({
+  "src/data/commands/triggers.ts"() {
     "use strict";
+    init_expected();
     init_client();
     init_output();
     init_helpers();
     init_utils();
-    init_terminal_output();
-    init_workspace();
-    init_layout();
-    init_base_binding();
-    init_base_id();
-    init_expected();
-    BASE_META_FILE = "base.yaml";
-    BASE_ID_FIELD = "base_id";
   }
 });
 
@@ -25292,27 +27844,55 @@ var program_exports = {};
 __export(program_exports, {
   DATA_NAMESPACES: () => DATA_NAMESPACES,
   buildDataProgram: () => buildDataProgram,
+  handleParserExit: () => handleParserExit,
   isDataNamespace: () => isDataNamespace,
+  routeErrorsToCli: () => routeErrorsToCli,
   runDataCommand: () => runDataCommand,
   withBaseOption: () => withBaseOption,
   withDataGlobals: () => withDataGlobals
 });
-import { Command as Command2 } from "commander";
+import { Command as Command22 } from "commander";
 function withDataGlobals(command2) {
   return command2.option("--org <uuid>", "Organization to operate against (overrides .wayai.yaml)").option("--output <format>", "Output format: json or table", "table").option("--json", "Shorthand for --output json");
 }
-function withBaseOption(command2) {
-  return command2.option("--base <id>", "Base id (or set WAYAI_BASE)");
-}
 function routeErrorsToCli(command2) {
   command2.exitOverride().configureOutput({ outputError: () => {
   } });
   for (const child of command2.commands) routeErrorsToCli(child);
   return command2;
 }
+function handleParserExit(err) {
+  const { code, exitCode } = err ?? {};
+  if (code === "commander.helpDisplayed" || code === "commander.version") return;
+  if (code === "commander.help") {
+    process.exitCode = exitCode || 1;
+    return;
+  }
+  if (typeof code === "string" && code.startsWith("commander.")) {
+    throw expected(err instanceof Error ? err.message : String(err));
+  }
+  throw err;
+}
 function buildDataProgram() {
-  const program = new Command2("wayai");
+  const program = new Command22("wayai");
   program.addCommand(withDataGlobals(buildBasesCommand()));
+  for (const build of [
+    buildRecordsCommand,
+    buildRecordTypesCommand,
+    buildRelationshipsCommand,
+    buildRelationshipTypesCommand,
+    buildQueryRelationshipsCommand,
+    buildFilesCommand,
+    buildFileTypesCommand,
+    buildAttachmentsCommand,
+    buildToolsetsCommand,
+    buildActionsCommand,
+    buildTriggersCommand,
+    buildInboundWebhooksCommand,
+    buildSeedCommand
+  ]) {
+    program.addCommand(withBaseOption(withDataGlobals(build())));
+  }
   program.hook("preAction", (_thisCommand, actionCommand) => {
     setDataOrgOverride(globals(actionCommand).org);
   });
@@ -25326,27 +27906,32 @@ async function runDataCommand(namespace, args2) {
   try {
     await program.parseAsync(["node", "wayai", namespace, ...args2]);
   } catch (err) {
-    const { code, exitCode } = err ?? {};
-    if (code === "commander.helpDisplayed" || code === "commander.version") return;
-    if (code === "commander.help") {
-      process.exitCode = exitCode || 1;
-      return;
-    }
-    if (typeof code === "string" && code.startsWith("commander.")) {
-      throw expected(err instanceof Error ? err.message : String(err));
-    }
-    throw err;
+    handleParserExit(err);
   }
 }
 var init_program = __esm({
   "src/data/program.ts"() {
     "use strict";
+    init_actions();
+    init_attachments();
     init_bases();
+    init_file_types();
+    init_files();
+    init_inbound_webhooks();
+    init_query_relationships();
+    init_record_types();
+    init_records();
+    init_relationship_types();
+    init_relationships();
+    init_seed();
+    init_toolsets();
+    init_triggers();
     init_helpers();
     init_expected();
     init_org_context();
     init_registry();
     init_registry();
+    init_helpers();
   }
 });
 
@@ -25356,9 +27941,9 @@ init_errors2();
 init_mask_secrets();
 init_utils();
 init_registry();
-import { readFileSync as readFileSync21 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname9, join as join28 } from "path";
+import { readFileSync as readFileSync26 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname10, join as join29 } from "path";
 
 // src/lib/version-refresh.ts
 init_version_cache();
@@ -25513,14 +28098,14 @@ Run \`wayai admin skill install\` to update.`);
 }
 
 // src/index.ts
-var __dirname = dirname9(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync21(join28(__dirname, "..", "package.json"), "utf-8"));
+var __dirname = dirname10(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(readFileSync26(join29(__dirname, "..", "package.json"), "utf-8"));
 var [, , command, ...args] = process.argv;
 var isBackgroundRefresh = command === REFRESH_COMMAND;
 if (!isBackgroundRefresh) initSentry(command, pkg.version);
 async function main() {
   if (shouldInterceptHelp(command, args, /* @__PURE__ */ new Set([...OWN_HELP_COMMANDS, ...DATA_NAMESPACES]))) {
-    printHelp3();
+    await printHelp3();
     return;
   }
   if (command && !wantsHelp(args)) {
@@ -25712,7 +28297,7 @@ async function main() {
     case "--help":
     case "-h":
     case void 0:
-      printHelp3();
+      await printHelp3();
       break;
     case "--version":
     case "-v":
@@ -25725,12 +28310,18 @@ async function main() {
         break;
       }
       console.error(`Unknown command: ${command}`);
-      printHelp3();
+      await printHelp3();
       process.exit(1);
     }
   }
 }
-function printHelp3() {
+async function dataHelpBlock() {
+  const { buildDataProgram: buildDataProgram2 } = await Promise.resolve().then(() => (init_program(), program_exports));
+  const namespaces = buildDataProgram2().commands;
+  const width = Math.max(...namespaces.map((c) => c.name().length));
+  return namespaces.map((c) => `  ${c.name().padEnd(width)}  ${c.description()}`.trimEnd()).join("\n");
+}
+async function printHelp3() {
   console.log(`
 wayai \u2014 WayAI CLI
 
@@ -25778,12 +28369,11 @@ Commands:
   report edit        Amend your own pending report (title/description/error/steps/context)
   update             Update CLI to the latest version
 
-Data (bases):
-  bases              Manage bases (list/get/create/update/delete, previews, promote)
+Data \u2014 one namespace per entity. Run \`wayai <namespace> --help\` for its tree.
+${await dataHelpBlock()}
   bases promote      Promote a preview base to production (distinct from \`publish\`, which promotes a hub)
   bases use <base>   Bind this worktree to a base (\`wayai use\` binds a hub)
   bases unbind       Clear this worktree's base binding
-  Run \`wayai bases --help\` for the full tree.
 
 Flags:
   --yes, -y              Skip confirmation prompts (useful for CI and scripting)
@@ -25854,7 +28444,7 @@ async function runForeground() {
   try {
     await main();
     if (command && !SKIP_UPDATE_CHECK.includes(command) && !wantsHelp(args)) {
-      showUpdateNudges(pkg.version, fileURLToPath2(import.meta.url));
+      showUpdateNudges(pkg.version, fileURLToPath3(import.meta.url));
     }
     await closeSentry();
   } catch (err) {