@datarails-ai/dr-cli 1.6.112 → 1.6.113

package/dist/cli.js

@@ -8,7 +8,7 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 // package.json
 var package_default = {
   name: "@datarails-ai/dr-cli",
-  version: "1.6.112",
+  version: "1.6.113",
   description: "Datarails CLI",
   type: "module",
   engines: {
@@ -69,7 +69,7 @@ var package_default = {
 };
 
 // src/buildInfo.ts
-var BUILD_TIME = "2026-10-08T11:22:19.091Z";
+var BUILD_TIME = "2026-10-09T10:02:15.002Z";
 function formatBuildTime(iso) {
   if (iso === "") return "";
   const d = new Date(iso);
@@ -371,10 +371,10 @@ function credentialsFilePath() {
   const override = process.env[CREDENTIALS_FILE_ENV];
   return override !== void 0 && override !== "" ? override : DEFAULT_CREDENTIALS_FILE;
 }
-async function readCredentialsFile(path11) {
+async function readCredentialsFile(path12) {
   let raw;
   try {
-    raw = await readFile(path11, "utf8");
+    raw = await readFile(path12, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
@@ -383,17 +383,17 @@ async function readCredentialsFile(path11) {
   try {
     parsed2 = JSON.parse(raw);
   } catch {
-    throw new Error(`credential file ${path11} is not valid JSON`);
+    throw new Error(`credential file ${path12} is not valid JSON`);
   }
   try {
     return credentialsFileSchema.parse(parsed2);
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(`credential file ${path11} is malformed: ${reason}`, { cause: err });
+    throw new Error(`credential file ${path12} is malformed: ${reason}`, { cause: err });
   }
 }
-async function writeCredentialsFile(path11, creds) {
-  await mkdir(dirname(path11), { recursive: true, mode: 448 });
+async function writeCredentialsFile(path12, creds) {
+  await mkdir(dirname(path12), { recursive: true, mode: 448 });
   let next;
   try {
     next = credentialsFileSchema.parse({
@@ -402,15 +402,15 @@ async function writeCredentialsFile(path11, creds) {
     });
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(`refusing to write an unreadable credential file ${path11}: ${reason}`, {
+    throw new Error(`refusing to write an unreadable credential file ${path12}: ${reason}`, {
       cause: err
     });
   }
   const body = JSON.stringify(next, null, 2);
-  const tmp = `${path11}.${process.pid}.tmp`;
+  const tmp = `${path12}.${process.pid}.tmp`;
   await writeFile(tmp, body, { mode: 384 });
   await chmod(tmp, 384);
-  await rename(tmp, path11);
+  await rename(tmp, path12);
 }
 
 // src/auth/types.ts
@@ -580,10 +580,10 @@ var ScopeDeniedError = class extends Error {
    *   credential, not the `--server`/`--account` one. Named, the message points `dr whoami`
    *   at it; omitted, "this identity" is the one the reader just ran the command as.
    */
-  constructor(method, path11, code, required2, identity2) {
+  constructor(method, path12, code, required2, identity2) {
     super("");
     this.method = method;
-    this.path = path11;
+    this.path = path12;
     this.code = code;
     this.identity = identity2;
     this.name = "ScopeDeniedError";
@@ -2172,12 +2172,12 @@ var AuthorizedClient = class _AuthorizedClient {
    * Relative paths are prefixed with {@link AuthorizedClient.host}; absolute
    * `http(s)://` URLs pass through unchanged. Mirrors `client.go:79-94` `Do`.
    */
-  async do(method, path11, body, options) {
+  async do(method, path12, body, options) {
     const sentBearer = this.hasBearer();
-    let res = await this.doWithAuth(method, path11, body, options, true);
-    await _AuthorizedClient.throwIfScopeDenied(method, path11, res);
+    let res = await this.doWithAuth(method, path12, body, options, true);
+    await _AuthorizedClient.throwIfScopeDenied(method, path12, res);
     if (this.isAuthRejected(res) && sentBearer && !this.isCookieless()) {
-      res = await this.doWithAuth(method, path11, body, options, false);
+      res = await this.doWithAuth(method, path12, body, options, false);
     }
     if (this.isAuthRejected(res)) {
       try {
@@ -2186,11 +2186,11 @@ var AuthorizedClient = class _AuthorizedClient {
           host: this._authHost
         });
         this._session = fresh;
-        res = await this.doWithAuth(method, path11, body, options, true);
+        res = await this.doWithAuth(method, path12, body, options, true);
       } catch (err) {
         _AuthorizedClient.logRefreshFailure("post-401 force-refresh", err);
       }
-      await _AuthorizedClient.throwIfScopeDenied(method, path11, res);
+      await _AuthorizedClient.throwIfScopeDenied(method, path12, res);
     }
     if (!this.isAuthRejected(res) && res.ok) {
       try {
@@ -2227,11 +2227,11 @@ var AuthorizedClient = class _AuthorizedClient {
    *
    * @internal
    */
-  async doWithAuth(method, path11, body, options, includeBearer) {
+  async doWithAuth(method, path12, body, options, includeBearer) {
     if (includeBearer) {
       await this.ensureFreshAuth(JWT_REFRESH_BUFFER_MS, options?.signal);
     }
-    const url = this.resolveUrl(path11);
+    const url = this.resolveUrl(path12);
     const headers = new Headers();
     const hasBody = body !== void 0 && body !== null;
     this.applyAuthHeaders(headers, hasBody, includeBearer);
@@ -2258,37 +2258,37 @@ var AuthorizedClient = class _AuthorizedClient {
    * empty bodies (incl. 204 and `""`). Throws on non-2xx with the truncated
    * body in the message. Mirrors `client.go:137-138` + `doJSON` happy path.
    */
-  async getJSON(path11, options) {
-    return this.requestJson("GET", path11, void 0, options);
+  async getJSON(path12, options) {
+    return this.requestJson("GET", path12, void 0, options);
   }
   /**
    * Issues a `POST` with `payload` JSON-encoded as the body and decodes the
    * JSON response into `T`. Mirrors `client.go:142` `PostJSON`.
    */
-  async postJSON(path11, payload, options) {
-    return this.requestJson("POST", path11, payload, options);
+  async postJSON(path12, payload, options) {
+    return this.requestJson("POST", path12, payload, options);
   }
   /**
    * Issues a `PUT` with `payload` JSON-encoded as the body and decodes the
    * JSON response into `T`. Mirrors `client.go:148` `PutJSON`.
    */
-  async putJSON(path11, payload, options) {
-    return this.requestJson("PUT", path11, payload, options);
+  async putJSON(path12, payload, options) {
+    return this.requestJson("PUT", path12, payload, options);
   }
   /**
    * Issues a `PATCH` with `payload` JSON-encoded as the body and decodes the
    * JSON response into `T`. Symmetric with {@link AuthorizedClient.putJSON}.
    */
-  async patchJSON(path11, payload, options) {
-    return this.requestJson("PATCH", path11, payload, options);
+  async patchJSON(path12, payload, options) {
+    return this.requestJson("PATCH", path12, payload, options);
   }
   /**
    * Issues a `DELETE` (no body) and decodes the JSON response into `T`.
    * Mirrors `client.go:154` `DeleteJSON`. Callers needing a DELETE-with-body
    * should drop down to {@link AuthorizedClient.do} directly.
    */
-  async deleteJSON(path11, options) {
-    return this.requestJson("DELETE", path11, void 0, options);
+  async deleteJSON(path12, options) {
+    return this.requestJson("DELETE", path12, void 0, options);
   }
   /**
    * Issues a `POST` with a `multipart/form-data` body composed of `fields`
@@ -2318,7 +2318,7 @@ var AuthorizedClient = class _AuthorizedClient {
    * passed as `body`, mirroring Go's `writer.FormDataContentType()` override
    * at `client.go:191`.
    */
-  async postMultipart(path11, fields, file, options) {
+  async postMultipart(path12, fields, file, options) {
     const fd = new FormData();
     for (const [k, v] of Object.entries(fields)) {
       fd.set(k, v);
@@ -2332,7 +2332,7 @@ var AuthorizedClient = class _AuthorizedClient {
       fd.set(options.fileFieldName, file, options.filename);
     }
     await this.ensureFreshAuth(JWT_REFRESH_BUFFER_MS, options?.signal);
-    const url = this.resolveUrl(path11);
+    const url = this.resolveUrl(path12);
     const headers = new Headers();
     this.applyAuthHeaders(headers, true, true);
     headers.delete("Content-Type");
@@ -2343,19 +2343,19 @@ var AuthorizedClient = class _AuthorizedClient {
       signal: options?.signal
     });
     const text2 = await res.text();
-    _AuthorizedClient.throwIfScopeDeniedBody("POST", path11, res.status, text2);
+    _AuthorizedClient.throwIfScopeDeniedBody("POST", path12, res.status, text2);
     if (res.status === 401 || res.status === 403) {
-      throw new SessionExpiredError(`POST ${path11} (HTTP ${res.status})`);
+      throw new SessionExpiredError(`POST ${path12} (HTTP ${res.status})`);
     }
     if (res.status < 200 || res.status >= 300) {
-      throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
+      throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
     }
     if (text2 === "" || text2 === '""') return null;
     try {
       return JSON.parse(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`POST ${path11}: decode: ${msg}`);
+      throw new Error(`POST ${path12}: decode: ${msg}`);
     }
   }
   /**
@@ -2368,7 +2368,7 @@ var AuthorizedClient = class _AuthorizedClient {
    * Same retry/auth semantics as `postMultipart`: bypasses the 401/403
    * replay ladder because the FormData body is single-shot.
    */
-  async postMultipartFiles(path11, fields, files, fileFieldName, options) {
+  async postMultipartFiles(path12, fields, files, fileFieldName, options) {
     if (fileFieldName === "") {
       throw new Error("postMultipartFiles: fileFieldName must be non-empty");
     }
@@ -2383,7 +2383,7 @@ var AuthorizedClient = class _AuthorizedClient {
       fd.append(fileFieldName, part.blob, part.filename);
     }
     await this.ensureFreshAuth(JWT_REFRESH_BUFFER_MS, options?.signal);
-    const url = this.resolveUrl(path11);
+    const url = this.resolveUrl(path12);
     const headers = new Headers();
     this.applyAuthHeaders(headers, true, true);
     headers.delete("Content-Type");
@@ -2394,19 +2394,19 @@ var AuthorizedClient = class _AuthorizedClient {
       signal: options?.signal
     });
     const text2 = await res.text();
-    _AuthorizedClient.throwIfScopeDeniedBody("POST", path11, res.status, text2);
+    _AuthorizedClient.throwIfScopeDeniedBody("POST", path12, res.status, text2);
     if (res.status === 401 || res.status === 403) {
-      throw new SessionExpiredError(`POST ${path11} (HTTP ${res.status})`);
+      throw new SessionExpiredError(`POST ${path12} (HTTP ${res.status})`);
     }
     if (res.status < 200 || res.status >= 300) {
-      throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
+      throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
     }
     if (text2 === "" || text2 === '""') return null;
     try {
       return JSON.parse(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`POST ${path11}: decode: ${msg}`);
+      throw new Error(`POST ${path12}: decode: ${msg}`);
     }
   }
   /**
@@ -2420,7 +2420,7 @@ var AuthorizedClient = class _AuthorizedClient {
    * the requestJson retry ladder because the FormData body is
    * single-shot.
    */
-  async postMultipartNamed(path11, fields, files, options) {
+  async postMultipartNamed(path12, fields, files, options) {
     const fd = new FormData();
     for (const [k, v] of Object.entries(fields)) {
       fd.set(k, v);
@@ -2442,7 +2442,7 @@ var AuthorizedClient = class _AuthorizedClient {
       fd.set(part.fieldName, part.blob, part.filename);
     }
     await this.ensureFreshAuth(JWT_REFRESH_BUFFER_MS, options?.signal);
-    const url = this.resolveUrl(path11);
+    const url = this.resolveUrl(path12);
     const headers = new Headers();
     this.applyAuthHeaders(headers, true, true);
     headers.delete("Content-Type");
@@ -2453,19 +2453,19 @@ var AuthorizedClient = class _AuthorizedClient {
       signal: options?.signal
     });
     const text2 = await res.text();
-    _AuthorizedClient.throwIfScopeDeniedBody("POST", path11, res.status, text2);
+    _AuthorizedClient.throwIfScopeDeniedBody("POST", path12, res.status, text2);
     if (res.status === 401 || res.status === 403) {
-      throw new SessionExpiredError(`POST ${path11} (HTTP ${res.status})`);
+      throw new SessionExpiredError(`POST ${path12} (HTTP ${res.status})`);
     }
     if (res.status < 200 || res.status >= 300) {
-      throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
+      throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
     }
     if (text2 === "" || text2 === '""') return null;
     try {
       return JSON.parse(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`POST ${path11}: decode: ${msg}`);
+      throw new Error(`POST ${path12}: decode: ${msg}`);
     }
   }
   /**
@@ -2497,17 +2497,17 @@ var AuthorizedClient = class _AuthorizedClient {
    * Multipart callers MUST NOT route through here (body is not safely
    * replayable); they go through `do()` directly. See Task 1.14.
    */
-  async requestJson(method, path11, payload, options) {
+  async requestJson(method, path12, payload, options) {
     const body = payload === void 0 ? void 0 : JSON.stringify(payload);
     const sentBearer = this.hasBearer();
-    let res = await this.doWithAuth(method, path11, body, options, true);
-    await _AuthorizedClient.throwIfScopeDenied(method, path11, res);
+    let res = await this.doWithAuth(method, path12, body, options, true);
+    await _AuthorizedClient.throwIfScopeDenied(method, path12, res);
     let triedSessionOnly = false;
     let refreshed = false;
     let refreshErr;
     if (this.isAuthRejected(res) && sentBearer && !this.isCookieless()) {
       triedSessionOnly = true;
-      res = await this.doWithAuth(method, path11, body, options, false);
+      res = await this.doWithAuth(method, path12, body, options, false);
     }
     if (this.isAuthRejected(res)) {
       try {
@@ -2517,29 +2517,29 @@ var AuthorizedClient = class _AuthorizedClient {
         });
         this._session = fresh;
         refreshed = true;
-        res = await this.doWithAuth(method, path11, body, options, true);
+        res = await this.doWithAuth(method, path12, body, options, true);
       } catch (err) {
         refreshErr = err;
       }
     }
     if (this.isAuthRejected(res)) {
       const text3 = await res.text();
-      _AuthorizedClient.throwIfScopeDeniedBody(method, path11, res.status, text3);
+      _AuthorizedClient.throwIfScopeDeniedBody(method, path12, res.status, text3);
       if (refreshed || triedSessionOnly) {
         const attempted = refreshed ? "session-only retry and JWT refresh" : "session-only retry";
         throw new Error(
-          `${method} ${path11}: HTTP ${res.status} after ${attempted} (authenticated, but endpoint rejected \u2014 check permissions, tenant/org context, or body): ${truncate2(text3, 200)}`
+          `${method} ${path12}: HTTP ${res.status} after ${attempted} (authenticated, but endpoint rejected \u2014 check permissions, tenant/org context, or body): ${truncate2(text3, 200)}`
         );
       }
       if (refreshErr !== void 0) {
         const msg = refreshErr instanceof Error ? refreshErr.message : String(refreshErr);
-        throw new Error(`${method} ${path11}: ${msg} (HTTP ${res.status})`);
+        throw new Error(`${method} ${path12}: ${msg} (HTTP ${res.status})`);
       }
-      throw new SessionExpiredError(`${method} ${path11} (HTTP ${res.status})`);
+      throw new SessionExpiredError(`${method} ${path12} (HTTP ${res.status})`);
     }
     const text2 = await res.text();
     if (res.status < 200 || res.status >= 300) {
-      throw new Error(`${method} ${path11}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
+      throw new Error(`${method} ${path12}: HTTP ${res.status}: ${truncate2(text2, 200)}`);
     }
     try {
       await this._store.touch(this._serverKey, this._email);
@@ -2550,7 +2550,7 @@ var AuthorizedClient = class _AuthorizedClient {
       return JSON.parse(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`${method} ${path11}: decode: ${msg}`);
+      throw new Error(`${method} ${path12}: decode: ${msg}`);
     }
   }
   /**
@@ -2617,7 +2617,7 @@ var AuthorizedClient = class _AuthorizedClient {
    * caller, and `requestJson` reads it in its own final-messaging branch. The clone is read
    * only on a 403, so the ordinary path pays one status comparison.
    */
-  static async throwIfScopeDenied(method, path11, res) {
+  static async throwIfScopeDenied(method, path12, res) {
     if (res.status !== 403) return;
     let text2;
     try {
@@ -2625,22 +2625,22 @@ var AuthorizedClient = class _AuthorizedClient {
     } catch {
       return;
     }
-    _AuthorizedClient.throwIfScopeDeniedBody(method, path11, res.status, text2);
+    _AuthorizedClient.throwIfScopeDeniedBody(method, path12, res.status, text2);
   }
   /** {@link AuthorizedClient.throwIfScopeDenied} for a body already in hand — the multipart
    *  methods and `requestJson`'s final branch have read theirs and must not read it twice. */
-  static throwIfScopeDeniedBody(method, path11, status2, text2) {
+  static throwIfScopeDeniedBody(method, path12, status2, text2) {
     const denial = parseScopeDenial(status2, text2);
-    if (denial !== void 0) throw new ScopeDeniedError(method, path11, denial.code);
+    if (denial !== void 0) throw new ScopeDeniedError(method, path12, denial.code);
   }
   /** True iff `res` is the auth-rejection signal (401 or 403). */
   isAuthRejected(res) {
     return res.status === 401 || res.status === 403;
   }
   /** Prefixes relative paths with the configured host; absolute URLs pass through. */
-  resolveUrl(path11) {
-    if (path11.startsWith("http://") || path11.startsWith("https://")) return path11;
-    return this._host + path11;
+  resolveUrl(path12) {
+    if (path12.startsWith("http://") || path12.startsWith("https://")) return path12;
+    return this._host + path12;
   }
 };
 function truncate2(s, n) {
@@ -2653,8 +2653,8 @@ import { readdir, rm } from "fs/promises";
 import { basename, dirname as dirname2, join as join3 } from "path";
 var INDEX_PREFIX2 = "__index__:";
 var FileKeyringBackend = class _FileKeyringBackend {
-  constructor(path11) {
-    this.path = path11;
+  constructor(path12) {
+    this.path = path12;
   }
   path;
   load() {
@@ -2790,7 +2790,7 @@ var FileKeyringBackend = class _FileKeyringBackend {
    * A rotation that supplies a new expiry therefore keeps it, and a rotation
    * on its own leaves the date the metadata op carries.
    */
-  static applyOps(creds, ops, path11) {
+  static applyOps(creds, ops, path12) {
     const next = { ...creds };
     const order = ["apikey", "access", "refresh", "meta"];
     for (const slot of order) {
@@ -2798,7 +2798,7 @@ var FileKeyringBackend = class _FileKeyringBackend {
         const opSlot = _FileKeyringBackend.slotOf(creds, op.account);
         if (opSlot === void 0) {
           throw new Error(
-            `credential file ${path11} holds ${creds.server}:${creds.email} and cannot also store ${op.account}: it is a single-identity store. Remove that file to use the OS keychain instead.`
+            `credential file ${path12} holds ${creds.server}:${creds.email} and cannot also store ${op.account}: it is a single-identity store. Remove that file to use the OS keychain instead.`
           );
         }
         if (opSlot !== slot) continue;
@@ -3943,6 +3943,10 @@ var PROD_GATE_TIER_A = /* @__PURE__ */ new Set([
   "extable|delete",
   "entity|delete",
   "badge-command|delete",
+  // devices command-delete over several ids or a machine's whole WAITING queue
+  // (one token, N commands). Same hard delete N times over, so the word gate
+  // stays — once for the whole set, with every target on screen before it.
+  "badge-command-batch|delete",
   "function|delete",
   "lut|delete",
   "calcval|delete",
@@ -4153,6 +4157,9 @@ function confirmSecretPath() {
   }
   return path2.join(base, "dr-cs-cli", "delete-secret");
 }
+function confirmStateDir() {
+  return path2.dirname(confirmSecretPath());
+}
 function userConfigDir() {
   const platform = process.platform;
   if (platform === "win32") {
@@ -4217,8 +4224,8 @@ var NO_IDENTITY = {
 var started;
 var targetServer = "";
 var identity = NO_IDENTITY;
-function recordCommandStart(path11, nowMs) {
-  started = { command: path11.command, subcommand: path11.subcommand, startedAtMs: nowMs };
+function recordCommandStart(path12, nowMs) {
+  started = { command: path12.command, subcommand: path12.subcommand, startedAtMs: nowMs };
 }
 function setTelemetryTarget(server, id) {
   targetServer = server;
@@ -4329,22 +4336,22 @@ function formatSampleCell(v) {
 
 // src/commands/_setupCall.ts
 async function refuseIfProvisionedExternally(action, opts) {
-  const path11 = credentialsFilePath();
-  const creds = await readCredentialsFile(path11);
+  const path12 = credentialsFilePath();
+  const creds = await readCredentialsFile(path12);
   if (creds === void 0) return;
   if (creds.apiKey !== void 0) {
     if (opts?.allowApiKey === true) return;
     throw new Error(
-      `cannot ${action}: the credentials in ${path11} are an API key. Run \`dr login --api-key\` to replace the key (and update its \`apiKeyExpiresAt\` in that file, if set \u2014 nothing derives that date, and a stale one warns "expired" on every command), or \`dr logout\` to remove it and log in with a browser instead \u2014 it cannot be read back afterwards, so keep a copy if it is still needed.`
+      `cannot ${action}: the credentials in ${path12} are an API key. Run \`dr login --api-key\` to replace the key (and update its \`apiKeyExpiresAt\` in that file, if set \u2014 nothing derives that date, and a stale one warns "expired" on every command), or \`dr logout\` to remove it and log in with a browser instead \u2014 it cannot be read back afterwards, so keep a copy if it is still needed.`
     );
   }
   if (creds.apiKeyEnvVar !== void 0 && opts?.allowApiKey !== true) {
     throw new Error(
-      `cannot ${action}: the credentials in ${path11} name the environment variable ${creds.apiKeyEnvVar} as their API key, which is what later commands would authenticate as. Remove that file (\`dr logout\`) to log in with a browser instead.`
+      `cannot ${action}: the credentials in ${path12} name the environment variable ${creds.apiKeyEnvVar} as their API key, which is what later commands would authenticate as. Remove that file (\`dr logout\`) to log in with a browser instead.`
     );
   }
   if (isInteractiveFileLogin(creds)) return;
-  throw provisionedExternallyError(path11, action);
+  throw provisionedExternallyError(path12, action);
 }
 function isInteractiveFileLogin(creds) {
   return creds.sessionId !== void 0 && creds.sessionId !== "" || creds.interactiveLogin === true;
@@ -4364,26 +4371,26 @@ async function refuseLoginOverStoredApiKey(store, serverKey, email) {
     `cannot log in: ${serverKey}:${email} already holds an API key, which is what later commands would authenticate as \u2014 this login would succeed under your name and then run as the key. Run \`dr login --api-key\` to replace the key, or \`dr logout\` to remove it first \u2014 it cannot be read back afterwards, so keep a copy if it is still needed.`
   );
 }
-function provisionedExternallyError(path11, action) {
+function provisionedExternallyError(path12, action) {
   return new Error(
-    `cannot ${action}: the credentials in ${path11} were provisioned externally and carry no interactive session. Whatever provisioned them is responsible for renewing them; remove that file to log in interactively instead.`
+    `cannot ${action}: the credentials in ${path12} were provisioned externally and carry no interactive session. Whatever provisioned them is responsible for renewing them; remove that file to log in interactively instead.`
   );
 }
 async function refuseImpersonationWithCredentialFile() {
   const action = "log in as another user";
-  const path11 = credentialsFilePath();
-  const creds = await readCredentialsFile(path11);
+  const path12 = credentialsFilePath();
+  const creds = await readCredentialsFile(path12);
   if (creds === void 0) return;
   if (creds.apiKey !== void 0) {
     throw new Error(
-      `cannot ${action}: the credentials in ${path11} are an API key, and an API-key token cannot mint further credentials. Impersonating needs a browser login, so remove that file (\`dr logout\`) and run \`dr login --server <key>\` \u2014 the key cannot be read back afterwards, so keep a copy if it is still needed.`
+      `cannot ${action}: the credentials in ${path12} are an API key, and an API-key token cannot mint further credentials. Impersonating needs a browser login, so remove that file (\`dr logout\`) and run \`dr login --server <key>\` \u2014 the key cannot be read back afterwards, so keep a copy if it is still needed.`
     );
   }
   if (!isInteractiveFileLogin(creds)) {
-    throw provisionedExternallyError(path11, action);
+    throw provisionedExternallyError(path12, action);
   }
   throw new Error(
-    `cannot ${action}: ${path11} is in use as a single-identity credential store, which cannot hold a second identity. Remove that file to store sessions in the OS keychain instead.`
+    `cannot ${action}: ${path12} is in use as a single-identity credential store, which cannot hold a second identity. Remove that file to store sessions in the OS keychain instead.`
   );
 }
 function fileStoreServerKey(creds, serverFlag) {
@@ -4402,14 +4409,14 @@ function fileStoreServerKey(creds, serverFlag) {
   return creds.server;
 }
 async function resolveFileStore(serverFlag) {
-  const path11 = credentialsFilePath();
-  const creds = await readCredentialsFile(path11);
+  const path12 = credentialsFilePath();
+  const creds = await readCredentialsFile(path12);
   if (creds === void 0) return void 0;
   return {
-    store: new KeyringStore(new FileKeyringBackend(path11)),
+    store: new KeyringStore(new FileKeyringBackend(path12)),
     key: fileStoreServerKey(creds, serverFlag),
     email: creds.email,
-    path: path11
+    path: path12
   };
 }
 var DAY_MS = 864e5;
@@ -5334,7 +5341,7 @@ var V2_TERMINAL_HINTS = {
   access_denied: " (the login was refused, expired, or already used: run `dr login` again)",
   token_issuance_failed: " (the server could not issue the token: run `dr login` again to start a new login)"
 };
-async function poll(host, path11, deviceCode, options, terminalHints, onSuccess) {
+async function poll(host, path12, deviceCode, options, terminalHints, onSuccess) {
   const interval = options.interval ?? 2e3;
   const maxWait = options.maxWait ?? 6e5;
   const now = options.now ?? Date.now;
@@ -5354,7 +5361,7 @@ async function poll(host, path11, deviceCode, options, terminalHints, onSuccess)
       client_id: CLIENT_ID,
       device_code: deviceCode
     });
-    const res = await fetch(`${base}${path11}`, {
+    const res = await fetch(`${base}${path12}`, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: body.toString(),
@@ -5871,8 +5878,8 @@ var UserExistsError = class extends Error {
   }
 };
 async function create(client, payload, options) {
-  const path11 = "/api/it/users";
-  const res = await client.do("POST", path11, JSON.stringify(payload), options);
+  const path12 = "/api/it/users";
+  const res = await client.do("POST", path12, JSON.stringify(payload), options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     let parsed2;
@@ -5880,11 +5887,11 @@ async function create(client, payload, options) {
       parsed2 = JSON.parse(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`POST ${path11}: decode: ${msg}`);
+      throw new Error(`POST ${path12}: decode: ${msg}`);
     }
     const id = parsed2.data?.id;
     if (typeof id !== "number") {
-      throw new Error(`POST ${path11}: response missing data.id`);
+      throw new Error(`POST ${path12}: response missing data.id`);
     }
     return {
       id,
@@ -5903,11 +5910,11 @@ async function create(client, payload, options) {
       throw new UserExistsError(payload.email);
     }
   }
-  throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 async function registerIdentity(client, id, options) {
-  const path11 = `/api/it/users/${id}/register_identity`;
-  const res = await client.do("PUT", path11, void 0, options);
+  const path12 = `/api/it/users/${id}/register_identity`;
+  const res = await client.do("PUT", path12, void 0, options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     let body;
@@ -5915,11 +5922,11 @@ async function registerIdentity(client, id, options) {
       body = JSON.parse(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`PUT ${path11}: decode: ${msg}`);
+      throw new Error(`PUT ${path12}: decode: ${msg}`);
     }
     if (typeof body.sent !== "boolean") {
       throw new Error(
-        `PUT ${path11}: expected a boolean "sent" in the 2xx body, got ${truncate4(text2, 200)}`
+        `PUT ${path12}: expected a boolean "sent" in the 2xx body, got ${truncate4(text2, 200)}`
       );
     }
     return body.sent ? { status: "registered" } : { status: "already_exists" };
@@ -5933,36 +5940,36 @@ async function registerIdentity(client, id, options) {
     }
     return { status: "failed", ...reason !== void 0 ? { reason } : {} };
   }
-  throw new Error(`PUT ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`PUT ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 async function assignPermissionGroups(client, id, groupIds, options) {
-  const path11 = `/api/it/users/${id}/permission_groups`;
+  const path12 = `/api/it/users/${id}/permission_groups`;
   const body = JSON.stringify({ permission_groups: groupIds });
-  const res = await client.do("POST", path11, body, options);
+  const res = await client.do("POST", path12, body, options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     return;
   }
-  throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 async function updateUserRole(client, id, role, options) {
-  const path11 = `/api/it/users/${id}/permissions`;
+  const path12 = `/api/it/users/${id}/permissions`;
   const body = JSON.stringify({ role });
-  const res = await client.do("PUT", path11, body, options);
+  const res = await client.do("PUT", path12, body, options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     return;
   }
-  throw new Error(`PUT ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`PUT ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 async function removePermissionGroup(client, id, groupId, options) {
-  const path11 = `/api/it/users/${id}/permission_groups/${groupId}`;
-  const res = await client.do("DELETE", path11, void 0, options);
+  const path12 = `/api/it/users/${id}/permission_groups/${groupId}`;
+  const res = await client.do("DELETE", path12, void 0, options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     return;
   }
-  throw new Error(`DELETE ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`DELETE ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 var PasswordValidationError = class extends Error {
   errors;
@@ -5975,9 +5982,9 @@ var PasswordValidationError = class extends Error {
   }
 };
 async function setPassword(client, id, password, options) {
-  const path11 = `/api/it/users/${id}/set_password`;
+  const path12 = `/api/it/users/${id}/set_password`;
   const body = JSON.stringify({ password });
-  const res = await client.do("PUT", path11, body, options);
+  const res = await client.do("PUT", path12, body, options);
   if (res.status >= 200 && res.status < 300) {
     await res.text();
     return;
@@ -5995,7 +6002,7 @@ async function setPassword(client, id, password, options) {
       throw new PasswordValidationError(messages);
     }
   }
-  throw new Error(`PUT ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`PUT ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 var EmailInUseError = class extends Error {
   email;
@@ -6007,12 +6014,12 @@ var EmailInUseError = class extends Error {
 };
 async function updateUserEmail(client, id, newEmail, options) {
   const current = await get(client, id, options);
-  const path11 = `/api/it/users/${id}`;
+  const path12 = `/api/it/users/${id}`;
   const body = JSON.stringify({
     email: newEmail,
     excel_online_email: current.profile?.excel_online_email ?? null
   });
-  const res = await client.do("PUT", path11, body, options);
+  const res = await client.do("PUT", path12, body, options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     return { id, email: newEmail, previousEmail: current.email };
@@ -6020,7 +6027,7 @@ async function updateUserEmail(client, id, newEmail, options) {
   if (res.status === 400 && /already in use/i.test(text2)) {
     throw new EmailInUseError(newEmail);
   }
-  throw new Error(`PUT ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`PUT ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 var StoredEmailInvalidError = class extends Error {
   id;
@@ -6036,14 +6043,14 @@ var StoredEmailInvalidError = class extends Error {
 };
 async function setEmailNotifications(client, id, enabled, options) {
   const current = await get(client, id, options);
-  const path11 = `/api/it/users/${id}`;
+  const path12 = `/api/it/users/${id}`;
   const body = JSON.stringify({
     disable_emails: !enabled,
     // Echoed verbatim — see the note above. Never a new value.
     email: current.email,
     excel_online_email: current.profile?.excel_online_email ?? null
   });
-  const res = await client.do("PUT", path11, body, options);
+  const res = await client.do("PUT", path12, body, options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     return {
@@ -6056,7 +6063,7 @@ async function setEmailNotifications(client, id, enabled, options) {
   if (res.status === 400 && /valid email address/i.test(text2)) {
     throw new StoredEmailInvalidError(id, current.email);
   }
-  throw new Error(`PUT ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`PUT ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 async function getCanLoginAs(client, params = {}, options) {
   const qs = new URLSearchParams();
@@ -6069,8 +6076,8 @@ async function getCanLoginAs(client, params = {}, options) {
   if (params.pageSize !== void 0) {
     qs.set("page_size", String(params.pageSize));
   }
-  const path11 = qs.toString() === "" ? "/api/it/users/can_login_as" : `/api/it/users/can_login_as?${qs.toString()}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs.toString() === "" ? "/api/it/users/can_login_as" : `/api/it/users/can_login_as?${qs.toString()}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
     return { count: 0, next: null, previous: null, results: [] };
   }
@@ -6280,7 +6287,9 @@ function registerLoginAsCommand(root) {
 }
 
 // src/commands/devices.ts
+import { createHash as createHash2 } from "crypto";
 import { promises as fs3 } from "fs";
+import * as path4 from "path";
 
 // src/api/devices.ts
 var COMMANDS_V2_PAGE_SIZE = 500;
@@ -6289,7 +6298,7 @@ async function paginateCommandsV2(client, machineId, options) {
   let page = 1;
   for (; ; ) {
     const env = await client.getJSON(
-      `/api/badge/${machineId}/commands/v2?page_size=${COMMANDS_V2_PAGE_SIZE}&page=${page}`,
+      `/api/badge/${encodeURIComponent(machineId)}/commands/v2?page_size=${COMMANDS_V2_PAGE_SIZE}&page=${page}`,
       options
     );
     if (env === null) break;
@@ -6368,6 +6377,76 @@ function parsePositiveIntArg(raw, label) {
   return n;
 }
 
+// src/commands/_retry.ts
+var AMBIGUOUS_STATUSES = /* @__PURE__ */ new Set([502, 504, 524]);
+var MAX_BACKOFF_MS = 8e3;
+function isAbortError(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const name = err.name;
+  if (name === "AbortError" || name === "TimeoutError") return true;
+  return err.code === "ABORT_ERR";
+}
+function httpStatusOf(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const m = /\bHTTP (\d{3})\b/.exec(msg);
+  return m === null ? void 0 : Number(m[1]);
+}
+function classifyFailure(err) {
+  if (isAbortError(err)) return "abort";
+  const status2 = httpStatusOf(err);
+  if (status2 === void 0) return "transient";
+  if (AMBIGUOUS_STATUSES.has(status2)) return "ambiguous";
+  if (status2 === 429) return "transient";
+  if (status2 >= 400 && status2 < 500) return "client";
+  return "transient";
+}
+function defaultBackoffMs(failedAttempt) {
+  return Math.min(1e3 * 2 ** (failedAttempt - 1), MAX_BACKOFF_MS);
+}
+async function sleep2(ms, signal) {
+  if (ms <= 0) return;
+  if (signal?.aborted === true) throw abortErrorFor(signal);
+  await new Promise((resolve3, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve3();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(abortErrorFor(signal));
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function abortErrorFor(signal) {
+  const reason = signal?.reason;
+  if (reason instanceof Error) return reason;
+  return Object.assign(new Error("This operation was aborted"), {
+    name: "AbortError"
+  });
+}
+async function retryAsync(fn, opts) {
+  const retries = Number.isFinite(opts.retries) ? Math.max(0, Math.floor(opts.retries)) : 0;
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const kind = classifyFailure(err);
+      const retryable = kind === "transient" || kind !== "abort" && opts.alsoRetry?.(err) === true;
+      if (!retryable || attempt > retries) throw err;
+      const delay = opts.delayMs ?? defaultBackoffMs;
+      const waitMs = typeof delay === "function" ? delay(attempt) : delay;
+      opts.onRetry?.(attempt, err, waitMs);
+      await sleep2(waitMs, opts.signal);
+    }
+  }
+}
+
+// src/commands/_shellQuote.ts
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
 // src/commands/devices.ts
 async function runDevicesList(cfg) {
   const devices = await list3(cfg.client, { signal: cfg.signal });
@@ -6419,7 +6498,7 @@ async function runDevicesDownloadLogs(cfg) {
   if (cfg.uuid === "") {
     throw new Error("uuid is required");
   }
-  const path11 = `/api/it/devices/request_logs/${cfg.uuid}`;
+  const path12 = `/api/it/devices/request_logs/${cfg.uuid}`;
   const res = await downloadLogsStream(cfg.client, cfg.uuid, {
     signal: cfg.signal
   });
@@ -6431,10 +6510,10 @@ async function runDevicesDownloadLogs(cfg) {
   }
   if (res.status < 200 || res.status >= 300) {
     await res.text();
-    throw new Error(`GET ${path11}: HTTP ${res.status}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}`);
   }
   if (res.body === null) {
-    throw new Error(`GET ${path11}: empty response body`);
+    throw new Error(`GET ${path12}: empty response body`);
   }
   if (cfg.output === "-") {
     const reader = res.body.getReader();
@@ -6503,6 +6582,210 @@ async function runDevicesCommandDelete(cfg) {
     }
   });
 }
+var ERR_IDS_AND_ALL_QUEUED = "pass command ids OR --all-queued, not both";
+var ERR_ALL_QUEUED_NEEDS_MACHINE = "--all-queued needs --machine <machine_id> (find it with 'dr devices list --json')";
+var ERR_PLAN_NEEDS_ALL_QUEUED = "--plan only applies to --all-queued";
+var ERR_CONFIRM_NEEDS_PLAN = "--all-queued with --confirm-token also needs --plan \u2014 paste the exact confirm command the plan printed";
+function badgeBatchAction(id) {
+  return { resource: "badge-command-batch", id, verb: "delete" };
+}
+function shortHash(key) {
+  return createHash2("sha256").update(key).digest("hex").slice(0, 12);
+}
+function buildBadgeCommandBatchAction(ids) {
+  const sorted = [...new Set(ids)].sort((a, b) => a - b);
+  return badgeBatchAction(shortHash(`ids:${sorted.join(",")}`));
+}
+function badgeQueuePlanId(machineId, dataQuery, ids) {
+  const sorted = [...new Set(ids)].sort((a, b) => a - b);
+  return shortHash(`queue:${machineId}|dq=${dataQuery ?? ""}|ids=${sorted.join(",")}`);
+}
+function buildBadgeQueuePlanAction(planId) {
+  return badgeBatchAction(planId);
+}
+function badgePlanDir() {
+  return path4.join(confirmStateDir(), "badge-command-plans");
+}
+function badgePlanPath(planId) {
+  if (!/^[0-9a-f]{12}$/.test(planId)) {
+    throw new Error(`invalid --plan "${planId}" \u2014 paste the confirm command the plan printed`);
+  }
+  return path4.join(badgePlanDir(), `${planId}.json`);
+}
+async function writeBadgeQueuePlan(planId, plan) {
+  const dir = badgePlanDir();
+  await fs3.mkdir(dir, { recursive: true, mode: 448 });
+  const cutoff = Date.now() - CONFIRM_TOKEN_TTL_MS;
+  for (const name of await fs3.readdir(dir)) {
+    const file = path4.join(dir, name);
+    try {
+      if ((await fs3.stat(file)).mtimeMs < cutoff) await fs3.rm(file, { force: true });
+    } catch {
+    }
+  }
+  await fs3.writeFile(badgePlanPath(planId), JSON.stringify(plan), { mode: 384 });
+}
+async function readBadgeQueuePlan(planId, machineId, dataQuery) {
+  let raw;
+  try {
+    raw = await fs3.readFile(badgePlanPath(planId), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(
+        `plan ${planId} was not found on this computer \u2014 it expired or was made elsewhere. Re-run the command without --confirm-token and --plan to plan again.`
+      );
+    }
+    throw err;
+  }
+  let plan;
+  try {
+    plan = JSON.parse(raw);
+  } catch {
+    throw new Error(`plan ${planId} is unreadable \u2014 plan again`);
+  }
+  const ids = Array.isArray(plan.ids) ? plan.ids : [];
+  const ok = plan.machineId === machineId && (plan.dataQuery ?? void 0) === dataQuery && ids.length > 0 && ids.every((n) => Number.isInteger(n) && n > 0) && badgeQueuePlanId(machineId, dataQuery, ids) === planId;
+  if (!ok) {
+    throw new Error(
+      `plan ${planId} does not match --machine / --data-query, or was changed \u2014 plan again`
+    );
+  }
+  return [...new Set(ids)].sort((a, b) => a - b);
+}
+async function removeBadgeQueuePlan(planId) {
+  try {
+    await fs3.rm(badgePlanPath(planId), { force: true });
+  } catch {
+  }
+}
+async function runDevicesCommandDeleteBatch(cfg) {
+  const machineId = cfg.machineId ?? "";
+  const planning = isPlanPhase(cfg.token);
+  if (cfg.allQueued && cfg.ids.length > 0) throw new Error(ERR_IDS_AND_ALL_QUEUED);
+  if (cfg.allQueued && machineId === "") throw new Error(ERR_ALL_QUEUED_NEEDS_MACHINE);
+  if (!cfg.allQueued && cfg.planId !== void 0) throw new Error(ERR_PLAN_NEEDS_ALL_QUEUED);
+  if (cfg.allQueued && !planning && cfg.planId === void 0) {
+    throw new Error(ERR_CONFIRM_NEEDS_PLAN);
+  }
+  const explicitIds = [...new Set(cfg.ids)].sort((a, b) => a - b);
+  if (!cfg.allQueued && explicitIds.length === 0) {
+    throw new Error("at least one command id is required");
+  }
+  let plannedIds;
+  if (!cfg.allQueued) {
+    await preflightConfirmToken(buildBadgeCommandBatchAction(explicitIds), cfg.token);
+  } else if (cfg.planId !== void 0) {
+    plannedIds = await readBadgeQueuePlan(cfg.planId, machineId, cfg.dataQuery);
+    await preflightConfirmToken(buildBadgeQueuePlanAction(cfg.planId), cfg.token);
+  }
+  const readQueue = machineId !== "" && (planning || isProdServer(cfg.serverFlag));
+  const queue = readQueue ? await commands(cfg.client, machineId, { signal: cfg.signal }) : [];
+  const byId = new Map(queue.map((c) => [c.id, c]));
+  let ids;
+  let action;
+  let confirmCmd;
+  let planId;
+  const machineArg = machineId === "" ? "" : ` --machine ${shellQuote(machineId)}`;
+  const dqArg = cfg.dataQuery === void 0 ? "" : ` --data-query ${cfg.dataQuery}`;
+  if (cfg.allQueued) {
+    if (plannedIds !== void 0) {
+      ids = plannedIds;
+      planId = cfg.planId;
+    } else {
+      ids = [...byId.values()].filter((c) => cfg.dataQuery === void 0 || c.data_query === cfg.dataQuery).map((c) => c.id).sort((a, b) => a - b);
+      if (ids.length === 0) {
+        const filter = cfg.dataQuery === void 0 ? "" : ` for data query ${cfg.dataQuery}`;
+        cfg.out.write(
+          `(no queued commands${filter} on machine ${machineId} \u2014 nothing to delete)
+`
+        );
+        return;
+      }
+      planId = badgeQueuePlanId(machineId, cfg.dataQuery, ids);
+      await writeBadgeQueuePlan(planId, {
+        machineId,
+        dataQuery: cfg.dataQuery ?? null,
+        ids
+      });
+    }
+    action = buildBadgeQueuePlanAction(planId);
+    confirmCmd = `dr devices command-delete${machineArg} --all-queued${dqArg} --plan ${planId} --server ${cfg.serverFlag}`;
+  } else {
+    ids = explicitIds;
+    action = buildBadgeCommandBatchAction(ids);
+    confirmCmd = `dr devices command-delete ${ids.join(" ")}${machineArg} --server ${cfg.serverFlag}`;
+  }
+  await twoStepConfirm({
+    out: cfg.out,
+    action,
+    token: cfg.token,
+    server: cfg.serverFlag,
+    confirmCmd,
+    describe: async () => {
+      const scope = machineId === "" ? "" : ` on machine ${machineId}` + (cfg.dataQuery === void 0 ? "" : ` (data query ${cfg.dataQuery})`);
+      const lines = [`${ids.length} badge commands${scope}:`];
+      for (const id of ids) {
+        const c = byId.get(id);
+        if (c !== void 0) {
+          lines.push(
+            `command ${id}: ${strOr(c.action, "-")} ${strOr(c.status, "-")} data_query=${fmtIntOrDash(c.data_query ?? null)} updated=${c.update_time}`
+          );
+        } else if (readQueue) {
+          lines.push(
+            `command ${id}: (not in this machine's WAITING queue \u2014 will still attempt delete)`
+          );
+        } else {
+          lines.push(`command ${id}`);
+        }
+      }
+      if (cfg.allQueued) {
+        lines.push("(only these commands; anything queued after the plan is left alone)");
+      }
+      return lines;
+    },
+    execute: async () => {
+      extendForBatch(cfg.extendTimeout, ids.length);
+      const failed = [];
+      const gone = [];
+      let deleted = 0;
+      const summary = () => `Deleted ${deleted} of ${ids.length} badge commands` + (gone.length > 0 ? `; ${gone.length} already gone` : "") + (failed.length > 0 ? `; ${failed.length} failed: ${failed.join(", ")}` : "") + ".\n";
+      try {
+        for (const id of ids) {
+          try {
+            await commandDelete(cfg.client, id, { signal: cfg.signal });
+            deleted += 1;
+            cfg.out.write(`Deleted badge command ${id}.
+`);
+          } catch (err) {
+            if (cfg.signal.aborted) {
+              const done = deleted + gone.length + failed.length;
+              cfg.out.write(`Stopped after ${done} of ${ids.length} badge commands. ${summary()}`);
+              throw err;
+            }
+            if (cfg.allQueued && httpStatusOf(err) === 404) {
+              cfg.out.write(`Badge command ${id} is already gone (HTTP 404) \u2014 skipped.
+`);
+              gone.push(id);
+              continue;
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            cfg.out.write(`warning: badge command ${id} failed to delete: ${msg}
+`);
+            failed.push(id);
+          }
+        }
+      } finally {
+        if (planId !== void 0) await removeBadgeQueuePlan(planId);
+      }
+      cfg.out.write(summary());
+      if (failed.length > 0) {
+        throw new Error(
+          `${failed.length} of ${ids.length} badge command deletes failed: ${failed.join(", ")}`
+        );
+      }
+    }
+  });
+}
 function writeTable(out, rows) {
   if (rows.length === 0) return;
   const widths = [];
@@ -6747,24 +7030,64 @@ function registerDevicesCommand(root) {
   });
   addServerFlag(commandsCmd);
   addAccountFlag(commandsCmd);
-  const commandDeleteCmd = devices.command("command-delete").description("Delete a queued/executed remote command by id (two-step confirm)").argument("<id>", "command id (positive integer)").option(
+  const commandDeleteCmd = devices.command("command-delete").description(
+    "Delete remote commands (two-step confirm): one id, several ids, or every WAITING command on a machine (--machine <machine_id> --all-queued). Several commands are one batch \u2014 one plan, one token, one confirmation."
+  ).argument("[ids...]", "command id(s) \u2014 positive integers; omit with --all-queued").option(
+    "--machine <machine_id>",
+    "Machine whose queue to read: required with --all-queued; with ids it adds each command's details to the plan"
+  ).option(
+    "--all-queued",
+    "Target every WAITING command in the machine's queue (as listed by `devices commands`)",
+    false
+  ).option("--data-query <id>", "With --all-queued: only commands for this data-query id").option(
+    "--plan <plan_id>",
+    "With --all-queued, on confirm: the plan id the plan printed in its confirm command. Exactly the commands that plan listed are deleted"
+  ).option(
     "--confirm-token <token>",
     "Token from a prior plan run \u2014 required to actually delete",
     ""
-  ).action(async (idStr, opts) => {
-    const id = parseSinglePositiveIntArg(idStr, "command");
-    const action = {
-      resource: "badge-command",
-      id: String(id),
-      verb: "delete"
-    };
-    await preflightConfirmToken(action, opts.confirmToken);
+  ).option("--timeout <seconds>", BATCH_TIMEOUT_FLAG_HELP).action(async (idStrs, opts) => {
+    const target = resolveCommandDeleteTarget(idStrs, opts);
+    if (target.kind === "single") {
+      const action = {
+        resource: "badge-command",
+        id: String(target.id),
+        verb: "delete"
+      };
+      await preflightConfirmToken(action, opts.confirmToken);
+      const serverKey2 = resolveServer(opts.server);
+      const setup2 = await setupCall(opts.server, opts.account, batchSetupOptions(opts.timeout));
+      try {
+        await runDevicesCommandDelete({
+          client: setup2.client,
+          id: target.id,
+          token: opts.confirmToken,
+          serverFlag: serverKey2,
+          signal: setup2.signal,
+          out: process.stdout
+        });
+      } finally {
+        setup2.cleanup();
+      }
+      return;
+    }
+    if (!target.allQueued) {
+      await preflightConfirmToken(buildBadgeCommandBatchAction(target.ids), opts.confirmToken);
+    } else if (target.planId !== void 0) {
+      await readBadgeQueuePlan(target.planId, target.machineId ?? "", target.dataQuery);
+      await preflightConfirmToken(buildBadgeQueuePlanAction(target.planId), opts.confirmToken);
+    }
     const serverKey = resolveServer(opts.server);
-    const setup = await setupCall(opts.server, opts.account);
+    const setup = await setupCall(opts.server, opts.account, batchSetupOptions(opts.timeout));
     try {
-      await runDevicesCommandDelete({
+      await runDevicesCommandDeleteBatch({
         client: setup.client,
-        id,
+        ids: target.ids,
+        machineId: target.machineId,
+        allQueued: target.allQueued,
+        dataQuery: target.dataQuery,
+        planId: target.planId,
+        extendTimeout: setup.extendTimeout,
         token: opts.confirmToken,
         serverFlag: serverKey,
         signal: setup.signal,
@@ -6777,14 +7100,41 @@ function registerDevicesCommand(root) {
   addServerFlag(commandDeleteCmd);
   addAccountFlag(commandDeleteCmd);
 }
+function resolveCommandDeleteTarget(idStrs, opts) {
+  const allQueued = opts.allQueued === true;
+  const machineId = opts.machine === void 0 || opts.machine === "" ? void 0 : opts.machine;
+  if (allQueued && idStrs.length > 0) throw new Error(ERR_IDS_AND_ALL_QUEUED);
+  if (allQueued && machineId === void 0) throw new Error(ERR_ALL_QUEUED_NEEDS_MACHINE);
+  if (!allQueued && idStrs.length === 0) {
+    throw new Error(
+      "pass one or more command ids, or --machine <machine_id> --all-queued to delete the whole queue"
+    );
+  }
+  if (opts.dataQuery !== void 0 && !allQueued) {
+    throw new Error("--data-query only filters --all-queued; with explicit ids, pass just the ids");
+  }
+  if (opts.plan !== void 0 && !allQueued) throw new Error(ERR_PLAN_NEEDS_ALL_QUEUED);
+  if (allQueued && !isPlanPhase(opts.confirmToken) && opts.plan === void 0) {
+    throw new Error(ERR_CONFIRM_NEEDS_PLAN);
+  }
+  const dataQuery = opts.dataQuery === void 0 ? void 0 : parseSinglePositiveIntArg(opts.dataQuery, "data query");
+  const planId = opts.plan === void 0 || opts.plan === "" ? void 0 : opts.plan;
+  const ids = [...new Set(idStrs.map((s) => parseSinglePositiveIntArg(s, "command")))].sort(
+    (a, b) => a - b
+  );
+  if (!allQueued && ids.length === 1 && machineId === void 0) {
+    return { kind: "single", id: ids[0] };
+  }
+  return { kind: "batch", ids, machineId, allQueued, dataQuery, planId };
+}
 
 // src/api/features.ts
 async function list4(client, params, options) {
-  let path11 = `/api/it/features?page=${params.page}&page_size=${params.pageSize}`;
+  let path12 = `/api/it/features?page=${params.page}&page_size=${params.pageSize}`;
   if (params.search !== void 0 && params.search.trim() !== "") {
-    path11 += "&search=" + rawQueryEscape(params.search.trim());
+    path12 += "&search=" + rawQueryEscape(params.search.trim());
   }
-  const out = await client.getJSON(path11, options);
+  const out = await client.getJSON(path12, options);
   return out ?? { count: 0, next: null, previous: null, results: [] };
 }
 async function listEnriched(client, options) {
@@ -7305,68 +7655,68 @@ async function listPermissionGroups(client, options) {
   return out ?? [];
 }
 async function createPermissionGroup(client, payload, options) {
-  const path11 = "/api/it/permission_groups";
-  const res = await client.do("POST", path11, JSON.stringify(payload), options);
+  const path12 = "/api/it/permission_groups";
+  const res = await client.do("POST", path12, JSON.stringify(payload), options);
   const text2 = await res.text();
   if (res.status < 200 || res.status >= 300) {
-    throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+    throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
   }
-  return parsePermissionGroup("POST", path11, text2);
+  return parsePermissionGroup("POST", path12, text2);
 }
-function parsePermissionGroup(method, path11, text2) {
+function parsePermissionGroup(method, path12, text2) {
   try {
     return JSON.parse(text2);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`${method} ${path11}: decode: ${msg} (body: ${truncate4(text2, 200)})`);
+    throw new Error(`${method} ${path12}: decode: ${msg} (body: ${truncate4(text2, 200)})`);
   }
 }
 async function getPermissionGroup(client, id, options) {
-  const path11 = `/api/it/permission_groups/${id}`;
-  const res = await client.do("GET", path11, void 0, options);
+  const path12 = `/api/it/permission_groups/${id}`;
+  const res = await client.do("GET", path12, void 0, options);
   const text2 = await res.text();
   if (res.status < 200 || res.status >= 300) {
-    throw new Error(`GET ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
   }
-  return parsePermissionGroup("GET", path11, text2);
+  return parsePermissionGroup("GET", path12, text2);
 }
 async function updatePermissionGroup(client, id, name, options) {
-  const path11 = `/api/it/permission_groups/${id}`;
-  const res = await client.do("PUT", path11, JSON.stringify({ name }), options);
+  const path12 = `/api/it/permission_groups/${id}`;
+  const res = await client.do("PUT", path12, JSON.stringify({ name }), options);
   const text2 = await res.text();
   if (res.status < 200 || res.status >= 300) {
-    throw new Error(`PUT ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+    throw new Error(`PUT ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
   }
-  return parsePermissionGroup("PUT", path11, text2);
+  return parsePermissionGroup("PUT", path12, text2);
 }
 async function deletePermissionGroup(client, id, options) {
-  const path11 = `/api/it/permission_groups/${id}`;
-  const res = await client.do("DELETE", path11, void 0, options);
+  const path12 = `/api/it/permission_groups/${id}`;
+  const res = await client.do("DELETE", path12, void 0, options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
-    throw new Error(`DELETE ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+    throw new Error(`DELETE ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
   }
 }
-function decodeJsonBody(method, path11, text2) {
+function decodeJsonBody(method, path12, text2) {
   try {
     return JSON.parse(text2);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`${method} ${path11}: decode: ${msg} (body: ${truncate4(text2, 200)})`);
+    throw new Error(`${method} ${path12}: decode: ${msg} (body: ${truncate4(text2, 200)})`);
   }
 }
 function redactPasswordsInBodyText(text2) {
   return text2.replace(/"password"\s*:\s*"(?:[^"\\]|\\.)*"/g, '"password":"[redacted]"');
 }
-async function orgMigrationRequest(client, method, path11, payload, options) {
-  const res = await client.do(method, path11, JSON.stringify(payload), options);
+async function orgMigrationRequest(client, method, path12, payload, options) {
+  const res = await client.do(method, path12, JSON.stringify(payload), options);
   const text2 = await res.text();
   if (res.status < 200 || res.status >= 300) {
     throw new Error(
-      `${method} ${path11}: HTTP ${res.status}: ${truncate4(redactPasswordsInBodyText(text2), 600)}`
+      `${method} ${path12}: HTTP ${res.status}: ${truncate4(redactPasswordsInBodyText(text2), 600)}`
     );
   }
-  return decodeJsonBody(method, path11, text2);
+  return decodeJsonBody(method, path12, text2);
 }
 async function exportCreate(client, payload, options) {
   return orgMigrationRequest(
@@ -7482,10 +7832,10 @@ var ALLOWED_ROLES = /* @__PURE__ */ new Set([
 ]);
 var DEFAULT_ROLE = "VIEWER";
 var REGISTER_IDENTITY_HEADER = "register_identity";
-async function readUsersCsv(path11) {
+async function readUsersCsv(path12) {
   let raw;
   try {
-    raw = await fs4.readFile(path11, "utf8");
+    raw = await fs4.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -7665,13 +8015,13 @@ async function getRoles(client, segment, options) {
   return out ?? [];
 }
 async function grantRoleToUsers(client, appSegment, payload, options) {
-  const path11 = `/api/${appSegment}/users/grant_permissions_bulk`;
-  const res = await client.do("POST", path11, JSON.stringify(payload), options);
+  const path12 = `/api/${appSegment}/users/grant_permissions_bulk`;
+  const res = await client.do("POST", path12, JSON.stringify(payload), options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     return;
   }
-  throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 async function getUserTableRoles(client, userId, options) {
   const out = await client.getJSON(
@@ -7688,14 +8038,14 @@ async function getUserPermissionFilters(client, userId, options) {
   return out ?? [];
 }
 async function setUserPermissionFilters(client, userId, newFilters, options) {
-  const path11 = `/api/it/users/${userId}/permission_filters`;
+  const path12 = `/api/it/users/${userId}/permission_filters`;
   const body = JSON.stringify({ new_filters: newFilters });
-  const res = await client.do("POST", path11, body, options);
+  const res = await client.do("POST", path12, body, options);
   const text2 = await res.text();
   if (res.status >= 200 && res.status < 300) {
     return;
   }
-  throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
+  throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncate4(text2, 200)}`);
 }
 async function getTableRoles(client, options) {
   return getRoles(client, "table", options);
@@ -8392,10 +8742,10 @@ var EXPECTED_HEADER2 = [
   "filter_excluded"
 ];
 var RESOURCES = /* @__PURE__ */ new Set(["table", "element", "role", "filter"]);
-async function readPermissionsCsv(path11) {
+async function readPermissionsCsv(path12) {
   let raw;
   try {
-    raw = await fs6.readFile(path11, "utf8");
+    raw = await fs6.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -8826,10 +9176,10 @@ function registerUsersBulkPermissionsCommand(users) {
 // src/commands/_emailRenameCsv.ts
 import { promises as fs7 } from "fs";
 var EXPECTED_HEADER3 = ["source", "target"];
-async function readEmailRenameCsv(path11) {
+async function readEmailRenameCsv(path12) {
   let raw;
   try {
-    raw = await fs7.readFile(path11, "utf8");
+    raw = await fs7.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -9382,10 +9732,10 @@ function registerUsersRegisterIdentityCommand(users) {
 
 // src/commands/_payload.ts
 import { promises as fs8 } from "fs";
-async function readAndParse(path11, flagName) {
+async function readAndParse(path12, flagName) {
   let raw;
   try {
-    raw = await fs8.readFile(path11, "utf8");
+    raw = await fs8.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read ${flagName}: ${m}`);
@@ -9398,15 +9748,15 @@ async function readAndParse(path11, flagName) {
     throw new Error(`parse ${flagName}: ${m}`);
   }
 }
-async function readJsonPayload(path11, flagName = "--payload-file") {
-  const parsed2 = await readAndParse(path11, flagName);
+async function readJsonPayload(path12, flagName = "--payload-file") {
+  const parsed2 = await readAndParse(path12, flagName);
   if (parsed2 === null || typeof parsed2 !== "object" || Array.isArray(parsed2)) {
     throw new Error(`parse ${flagName}: expected a JSON object`);
   }
   return parsed2;
 }
-async function readJsonPayloadList(path11, flagName = "--payload-file") {
-  const parsed2 = await readAndParse(path11, flagName);
+async function readJsonPayloadList(path12, flagName = "--payload-file") {
+  const parsed2 = await readAndParse(path12, flagName);
   if (Array.isArray(parsed2)) {
     return parsed2;
   }
@@ -9417,8 +9767,8 @@ async function readJsonPayloadList(path11, flagName = "--payload-file") {
   }
   throw new Error(`parse ${flagName}: expected a JSON array, got ${describeJsonValue(parsed2)}`);
 }
-async function readJsonPayloadObjectOrList(path11, flagName = "--payload-file") {
-  const parsed2 = await readAndParse(path11, flagName);
+async function readJsonPayloadObjectOrList(path12, flagName = "--payload-file") {
+  const parsed2 = await readAndParse(path12, flagName);
   if (Array.isArray(parsed2)) {
     return parsed2;
   }
@@ -10460,10 +10810,10 @@ function registerUsersCommand(root) {
 // src/commands/_groupCsv.ts
 import { promises as fs9 } from "fs";
 var EXPECTED_HEADER4 = ["group_name", "role", "members"];
-async function readGroupsCsv(path11) {
+async function readGroupsCsv(path12) {
   let raw;
   try {
-    raw = await fs9.readFile(path11, "utf8");
+    raw = await fs9.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -11947,8 +12297,8 @@ async function getData(client, params = {}, options) {
   if (params.organizationClassification !== void 0) {
     qs.set("organization_classification", params.organizationClassification);
   }
-  const path11 = qs.toString() === "" ? "/api/it/manager_screen/data" : `/api/it/manager_screen/data?${qs.toString()}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs.toString() === "" ? "/api/it/manager_screen/data" : `/api/it/manager_screen/data?${qs.toString()}`;
+  const out = await client.getJSON(path12, options);
   return out ?? EMPTY_PAGE;
 }
 
@@ -12125,7 +12475,7 @@ function registerSupportManagerCommand(root) {
 }
 
 // src/commands/templates.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { promises as fs10 } from "fs";
 
 // src/commands/_envelope.ts
@@ -12198,8 +12548,8 @@ function isUnionBranchNoise(entry, valueErrors) {
 var RAW_TABLES_BASE = "/finance-os/api/data_models/v1/raw";
 var AGGREGATE_POLL_INTERVAL_MS = 1e3;
 var AGGREGATE_POLL_TIMEOUT_MS = 6e4;
-async function startTask(client, label, path11, body, options) {
-  const res = await client.do("POST", path11, JSON.stringify(body), options);
+async function startTask(client, label, path12, body, options) {
+  const res = await client.do("POST", path12, JSON.stringify(body), options);
   if (res.status !== 202) {
     const text2 = await res.text();
     throw new Error(
@@ -12281,7 +12631,7 @@ var defaultSleep2 = (ms, signal) => new Promise((resolve3, reject) => {
   }, ms);
   signal?.addEventListener("abort", onAbort, { once: true });
 });
-async function pollTask(client, label, path11, options = {}) {
+async function pollTask(client, label, path12, options = {}) {
   const interval = options.pollIntervalMs ?? AGGREGATE_POLL_INTERVAL_MS;
   const timeout = options.timeoutMs ?? AGGREGATE_POLL_TIMEOUT_MS;
   const sleep3 = options.sleep ?? defaultSleep2;
@@ -12309,7 +12659,7 @@ async function pollTask(client, label, path11, options = {}) {
       }
       let result;
       try {
-        result = await getTaskOnce(client, label, path11, {
+        result = await getTaskOnce(client, label, path12, {
           signal: tickAc.signal
         });
       } catch (err) {
@@ -12361,10 +12711,10 @@ async function listMyOrgOnly(client, options) {
   return out ?? [];
 }
 async function get3(client, id, options) {
-  const path11 = `/api/templates/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/templates/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response (expected a template row)`);
+    throw new Error(`GET ${path12}: empty response (expected a template row)`);
   }
   return out;
 }
@@ -12392,8 +12742,8 @@ async function setFieldFx(client, fieldId, body, options) {
   return client.putJSON(`/api/templates/fields/${fieldId}`, body, options);
 }
 async function create2(client, dataModelId, name, options) {
-  const path11 = `/api/templates/data_models/${dataModelId}/templates`;
-  const out = await client.postJSON(path11, { name }, options);
+  const path12 = `/api/templates/data_models/${dataModelId}/templates`;
+  const out = await client.postJSON(path12, { name }, options);
   return out ?? {
     id: 0,
     name: "",
@@ -12401,7 +12751,7 @@ async function create2(client, dataModelId, name, options) {
   };
 }
 async function sample(client, id, params, options) {
-  const path11 = `${RAW_TABLES_BASE}/${id}/data`;
+  const path12 = `${RAW_TABLES_BASE}/${id}/data`;
   const body = {
     limit: params.rows,
     offset: params.offset
@@ -12412,9 +12762,9 @@ async function sample(client, id, params, options) {
   if (params.filters && params.filters.length > 0) {
     body["filters"] = [...params.filters];
   }
-  const out = await client.postJSON(path11, body, options);
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from sample endpoint`);
+    throw new Error(`POST ${path12}: empty response from sample endpoint`);
   }
   return out;
 }
@@ -12425,7 +12775,7 @@ async function distinct(client, id, fieldId, options = {}) {
 }
 var LEGACY_TABLES_BASE2 = "/finance-os/api/tables/v1";
 async function sampleLegacy(client, id, params, options) {
-  const path11 = `${LEGACY_TABLES_BASE2}/${id}/data`;
+  const path12 = `${LEGACY_TABLES_BASE2}/${id}/data`;
   const body = {
     limit: params.rows,
     offset: params.offset,
@@ -12434,17 +12784,17 @@ async function sampleLegacy(client, id, params, options) {
   if (params.select && params.select.length > 0) {
     body["select"] = params.select;
   }
-  const out = await client.postJSON(path11, body, options);
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from sample endpoint`);
+    throw new Error(`POST ${path12}: empty response from sample endpoint`);
   }
   return out;
 }
 async function distinctByNameLegacy(client, id, field, options) {
-  const path11 = `${LEGACY_TABLES_BASE2}/${id}/fields/by-name/${rawPathSegmentEscape(field)}/distinct`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `${LEGACY_TABLES_BASE2}/${id}/fields/by-name/${rawPathSegmentEscape(field)}/distinct`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from distinct endpoint`);
+    throw new Error(`GET ${path12}: empty response from distinct endpoint`);
   }
   return out;
 }
@@ -13136,7 +13486,7 @@ function buildSetFieldTypeAction(changes) {
     };
   }
   const canonical = changes.map((c) => `${c.fieldId}:${c.newType}`).slice().sort().join("|");
-  const sha = createHash2("sha256").update(canonical).digest("hex").slice(0, 12);
+  const sha = createHash3("sha256").update(canonical).digest("hex").slice(0, 12);
   return {
     resource: "field-batch",
     id: sha,
@@ -13575,10 +13925,10 @@ async function list7(client, options) {
   return out ?? [];
 }
 async function get4(client, id, options) {
-  const path11 = `/api/templates/data_models/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/templates/data_models/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response`);
+    throw new Error(`GET ${path12}: empty response`);
   }
   return out;
 }
@@ -14436,7 +14786,7 @@ function registerDashboardsCommand(root) {
 }
 
 // src/commands/folders.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 
 // src/api/folders.ts
 var FOLDER_ENTITY_TYPES = ["dashboard", "story"];
@@ -14461,17 +14811,17 @@ async function create4(client, entityType, name, parentId, options) {
   return out;
 }
 async function reorder(client, payload, options) {
-  const path11 = "/api/folders/reorder";
-  const res = await client.do("POST", path11, JSON.stringify(payload), options);
+  const path12 = "/api/folders/reorder";
+  const res = await client.do("POST", path12, JSON.stringify(payload), options);
   if (!res.ok) {
-    throw new Error(`POST ${path11}: HTTP ${res.status}: ${await res.text()}`);
+    throw new Error(`POST ${path12}: HTTP ${res.status}: ${await res.text()}`);
   }
 }
 async function move(client, folderId, parentId, options) {
-  const path11 = `/api/folders/${folderId}`;
-  const out = await client.patchJSON(path11, { parent_id: parentId }, options);
+  const path12 = `/api/folders/${folderId}`;
+  const out = await client.patchJSON(path12, { parent_id: parentId }, options);
   if (out === null) {
-    throw new Error(`unexpected empty response from PATCH ${path11}`);
+    throw new Error(`unexpected empty response from PATCH ${path12}`);
   }
   return out;
 }
@@ -14595,7 +14945,7 @@ function containerLabel(containerId, names) {
 }
 var itemKey = (i) => `${i.kind}:${i.id}`;
 function reorderConfirmId(entityType, containerArg, request) {
-  const sha = createHash3("sha256").update(request).digest("hex").slice(0, 12);
+  const sha = createHash4("sha256").update(request).digest("hex").slice(0, 12);
   return `${entityType}:${containerArg}:${sha}`;
 }
 function flagOffError(entityType, err) {
@@ -15486,19 +15836,19 @@ var CacheKeyHttpError = class extends Error {
   status;
   path;
   bodyText;
-  constructor(method, path11, status2, bodyText) {
-    super(`${method} ${path11}: HTTP ${status2}: ${truncate5(bodyText, 200)}`);
+  constructor(method, path12, status2, bodyText) {
+    super(`${method} ${path12}: HTTP ${status2}: ${truncate5(bodyText, 200)}`);
     this.name = "CacheKeyHttpError";
     this.status = status2;
-    this.path = path11;
+    this.path = path12;
     this.bodyText = bodyText;
   }
 };
-async function putOnce(client, path11, body, options) {
-  const res = await client.do("PUT", path11, body, options);
+async function putOnce(client, path12, body, options) {
+  const res = await client.do("PUT", path12, body, options);
   const text2 = await res.text();
   if (res.status !== 409 && (res.status < 200 || res.status >= 300)) {
-    throw new CacheKeyHttpError("PUT", path11, res.status, text2);
+    throw new CacheKeyHttpError("PUT", path12, res.status, text2);
   }
   if (text2 === "" || text2 === '""') {
     return { status: res.status, parsed: null };
@@ -15507,7 +15857,7 @@ async function putOnce(client, path11, body, options) {
     return { status: res.status, parsed: JSON.parse(text2) };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`PUT ${path11}: decode: ${msg}`);
+    throw new Error(`PUT ${path12}: decode: ${msg}`);
   }
 }
 function extractCacheKey(body) {
@@ -15521,8 +15871,8 @@ function extractCacheKey(body) {
   }
   return "";
 }
-function withCacheKey(path11, key) {
-  return `${path11}?cache_key=${encodeURIComponent(key)}`;
+function withCacheKey(path12, key) {
+  return `${path12}?cache_key=${encodeURIComponent(key)}`;
 }
 var CACHE_KEY_POLL_INTERVAL_MS = 500;
 var abortableSleep = (ms, signal) => new Promise((resolve3, reject) => {
@@ -15540,22 +15890,22 @@ var abortableSleep = (ms, signal) => new Promise((resolve3, reject) => {
   }, ms);
   signal?.addEventListener("abort", onAbort, { once: true });
 });
-async function putWithCacheKeyPolling(client, path11, payload, options = {}) {
+async function putWithCacheKeyPolling(client, path12, payload, options = {}) {
   const interval = options.pollIntervalMs ?? CACHE_KEY_POLL_INTERVAL_MS;
   const sleep3 = options.sleep ?? abortableSleep;
   const label = options.label ?? "data";
   const body = JSON.stringify(payload);
-  const first = await putOnce(client, path11, body, options);
+  const first = await putOnce(client, path12, body, options);
   if (first.status !== 409) {
     return first.parsed;
   }
   const cacheKey = extractCacheKey(first.parsed);
   if (cacheKey === "") {
     throw new Error(
-      `PUT ${path11}: 409 without cache_key: ${truncate5(JSON.stringify(first.parsed ?? ""), 200)}`
+      `PUT ${path12}: 409 without cache_key: ${truncate5(JSON.stringify(first.parsed ?? ""), 200)}`
     );
   }
-  const pollPath = withCacheKey(path11, cacheKey);
+  const pollPath = withCacheKey(path12, cacheKey);
   for (; ; ) {
     try {
       await sleep3(interval, options.signal);
@@ -15748,13 +16098,13 @@ function parseDrilldown(body) {
 async function exportDrilldownCsv(client, id, body, options = {}) {
   const interval = options.pollIntervalMs ?? CACHE_KEY_POLL_INTERVAL_MS;
   const sleep3 = options.sleep ?? abortableSleep;
-  const path11 = `/api/functions/${id}/drilldown/export_to_csv`;
+  const path12 = `/api/functions/${id}/drilldown/export_to_csv`;
   const payload = JSON.stringify(body);
-  let res = await putOnce(client, path11, payload, options);
+  let res = await putOnce(client, path12, payload, options);
   while (res.status === 409) {
     const key = extractCacheKey(res.parsed);
     if (key === "") {
-      throw new Error(`PUT ${path11}: 409 without cache_key: ${preview(res.parsed)}`);
+      throw new Error(`PUT ${path12}: 409 without cache_key: ${preview(res.parsed)}`);
     }
     for (; ; ) {
       try {
@@ -15781,12 +16131,12 @@ async function exportDrilldownCsv(client, id, body, options = {}) {
         if (e["is_ready"] === true) break;
       }
     }
-    res = await putOnce(client, withCacheKey(path11, key), payload, options);
+    res = await putOnce(client, withCacheKey(path12, key), payload, options);
   }
   const parsed2 = res.parsed;
   const reportId = parsed2 !== null && typeof parsed2 === "object" ? parsed2["drill_down_report_id"] : void 0;
   if (typeof reportId !== "number") {
-    throw new Error(`PUT ${path11}: no drill_down_report_id in ${preview(parsed2)}`);
+    throw new Error(`PUT ${path12}: no drill_down_report_id in ${preview(parsed2)}`);
   }
   const reportPath = `/api/dashboards/report/${reportId}?report_type=drill_down_report`;
   const report = await client.do("GET", reportPath, void 0, options);
@@ -16809,23 +17159,23 @@ function registerFunctionsCommand(root) {
 
 // src/api/semanticTables.ts
 async function list12(client, options) {
-  const path11 = "/finance-os/api/semantictables/v1/";
-  const out = await client.getJSON(path11, options);
+  const path12 = "/finance-os/api/semantictables/v1/";
+  const out = await client.getJSON(path12, options);
   if (out === null) {
     return { success: true, data: [], error: null };
   }
   return out;
 }
 async function get7(client, alias, options) {
-  const path11 = `/finance-os/api/semantictables/v1/by-alias/${rawPathSegmentEscape(alias)}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/finance-os/api/semantictables/v1/by-alias/${rawPathSegmentEscape(alias)}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from semantictables get`);
+    throw new Error(`GET ${path12}: empty response from semantictables get`);
   }
   return out;
 }
 async function data3(client, alias, params, options) {
-  const path11 = `/finance-os/api/semantictables/v1/${rawPathSegmentEscape(alias)}/data`;
+  const path12 = `/finance-os/api/semantictables/v1/${rawPathSegmentEscape(alias)}/data`;
   const body = {
     limit: params.rows,
     offset: params.offset,
@@ -16837,17 +17187,17 @@ async function data3(client, alias, params, options) {
   if (params.filters && params.filters.length > 0) {
     body["filters"] = params.filters;
   }
-  const out = await client.postJSON(path11, body, options);
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from semantictables data`);
+    throw new Error(`POST ${path12}: empty response from semantictables data`);
   }
   return out;
 }
 async function distinct2(client, alias, field, options) {
-  const path11 = `/finance-os/api/semantictables/v1/${rawPathSegmentEscape(alias)}/fields/by-alias/${rawPathSegmentEscape(field)}/distinct`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/finance-os/api/semantictables/v1/${rawPathSegmentEscape(alias)}/fields/by-alias/${rawPathSegmentEscape(field)}/distinct`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from semantictables distinct`);
+    throw new Error(`GET ${path12}: empty response from semantictables distinct`);
   }
   return out;
 }
@@ -17266,23 +17616,23 @@ function findByTableId(items, titleOf, tableId, variant) {
   return hits[0];
 }
 function tablePagePath(key, q) {
-  let path11 = `/OData.svc/${key}?$top=${q.top}&$skip=${q.skip}`;
+  let path12 = `/OData.svc/${key}?$top=${q.top}&$skip=${q.skip}`;
   if (q.select !== void 0 && q.select.length > 0) {
-    path11 += `&$select=${encodeURIComponent(q.select.join(","))}`;
+    path12 += `&$select=${encodeURIComponent(q.select.join(","))}`;
   }
   if (q.filter !== void 0 && q.filter !== "") {
-    path11 += `&$filter=${encodeURIComponent(q.filter)}`;
+    path12 += `&$filter=${encodeURIComponent(q.filter)}`;
   }
-  return path11;
+  return path12;
 }
-async function getXml(client, path11, accept, options) {
-  const res = await client.do("GET", path11, void 0, {
+async function getXml(client, path12, accept, options) {
+  const res = await client.do("GET", path12, void 0, {
     ...options,
     headers: { ...options?.headers, Accept: accept }
   });
   const body = await res.text();
   if (res.status < 200 || res.status >= 300) {
-    throw new Error(`GET ${path11}: HTTP ${res.status}: ${truncate4(body, 200)}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}: ${truncate4(body, 200)}`);
   }
   return body;
 }
@@ -17621,10 +17971,10 @@ async function list13(client, options) {
   return out;
 }
 async function get8(client, id, options) {
-  const path11 = `/api/storytelling/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/storytelling/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from storyboards get`);
+    throw new Error(`GET ${path12}: empty response from storyboards get`);
   }
   return out;
 }
@@ -17907,18 +18257,18 @@ async function list14(client, options) {
   return out ?? [];
 }
 async function get9(client, id, options) {
-  const path11 = `/api/extables/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/extables/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from extables get`);
+    throw new Error(`GET ${path12}: empty response from extables get`);
   }
   return out;
 }
 async function clone(client, id, name, options) {
-  const path11 = `/api/extables/${id}/clone`;
-  const out = await client.postJSON(path11, { name }, options);
+  const path12 = `/api/extables/${id}/clone`;
+  const out = await client.postJSON(path12, { name }, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from extables clone`);
+    throw new Error(`POST ${path12}: empty response from extables clone`);
   }
   return out;
 }
@@ -18184,18 +18534,18 @@ async function getMappedData(client, documentId, lutId, options) {
   return out ?? {};
 }
 async function create7(client, tableId, body, options) {
-  const path11 = `/api/templates/${tableId}/lutdocuments`;
-  const out = await client.postJSON(path11, body, options);
+  const path12 = `/api/templates/${tableId}/lutdocuments`;
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from lut create`);
+    throw new Error(`POST ${path12}: empty response from lut create`);
   }
   return out;
 }
 async function update3(client, id, body, options) {
-  const path11 = `/api/templates/lutdocuments/${id}`;
-  const out = await client.putJSON(path11, body, options);
+  const path12 = `/api/templates/lutdocuments/${id}`;
+  const out = await client.putJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`PUT ${path11}: empty response from lut update`);
+    throw new Error(`PUT ${path12}: empty response from lut update`);
   }
   return out;
 }
@@ -18213,19 +18563,19 @@ async function saveMappings(client, documentId, body, options = {}) {
   const sleep3 = options.sleep ?? defaultPollSleep;
   const now = options.now ?? Date.now;
   const deadline = now() + timeout;
-  const path11 = `/api/documents/${documentId}/web_update_lut`;
+  const path12 = `/api/documents/${documentId}/web_update_lut`;
   const payload = JSON.stringify(body);
-  const first = await postOnce(client, path11, payload, options.signal);
+  const first = await postOnce(client, path12, payload, options.signal);
   if (first.status === 200) {
     return toResult(first.text);
   }
   const cacheKey = extractCacheKey2(first.text);
   if (cacheKey === "") {
     throw new Error(
-      `POST ${path11}: HTTP ${first.status} without a cache_key to join: ${truncateBody(first.text)}`
+      `POST ${path12}: HTTP ${first.status} without a cache_key to join: ${truncateBody(first.text)}`
     );
   }
-  const pollPath = `${path11}?cache_key=${encodeURIComponent(cacheKey)}`;
+  const pollPath = `${path12}?cache_key=${encodeURIComponent(cacheKey)}`;
   for (; ; ) {
     if (now() >= deadline) {
       throw new Error(
@@ -18239,13 +18589,13 @@ async function saveMappings(client, documentId, body, options = {}) {
     }
   }
 }
-async function postOnce(client, path11, payload, signal) {
-  const res = await client.do("POST", path11, payload, { signal });
+async function postOnce(client, path12, payload, signal) {
+  const res = await client.do("POST", path12, payload, { signal });
   const text2 = await res.text();
   if (res.status === 200 || res.status === 409) {
     return { status: res.status, text: text2 };
   }
-  throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncateBody(text2)}`);
+  throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncateBody(text2)}`);
 }
 function extractCacheKey2(text2) {
   try {
@@ -18288,12 +18638,12 @@ var defaultPollSleep = (ms, signal) => new Promise((resolve3, reject) => {
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 async function getLutFile(client, documentId, options) {
-  const path11 = `/api/documents/${documentId}/lut-file`;
-  const res = await client.do("GET", path11, void 0, options);
+  const path12 = `/api/documents/${documentId}/lut-file`;
+  const res = await client.do("GET", path12, void 0, options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`GET ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}: ${truncated}`);
   }
   const ab = await res.arrayBuffer();
   return Buffer.from(ab);
@@ -18327,12 +18677,12 @@ async function calculate(client, id, body, reqOptions) {
   await client.putJSON(`/api/documents/${id}/calculate`, body, reqOptions);
 }
 async function downloadDebugZip(client, docVersionId, type, reqOptions) {
-  const path11 = `/api/documents/download_debug_zip_file/${docVersionId}?type=${type}`;
-  const res = await client.do("GET", path11, void 0, reqOptions);
+  const path12 = `/api/documents/download_debug_zip_file/${docVersionId}?type=${type}`;
+  const res = await client.do("GET", path12, void 0, reqOptions);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`GET ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}: ${truncated}`);
   }
   const ab = await res.arrayBuffer();
   return Buffer.from(ab);
@@ -18436,8 +18786,8 @@ async function startAddDynamicRanges(client, file, filename, dynamicRanges, reqO
   );
 }
 async function getDocumentJobStatusOnce(client, basePath, requestId, reqOptions) {
-  const path11 = `${basePath}/${requestId}`;
-  const res = await client.do("GET", path11, void 0, reqOptions);
+  const path12 = `${basePath}/${requestId}`;
+  const res = await client.do("GET", path12, void 0, reqOptions);
   if (res.status === 202) {
     await res.text();
     return { kind: "processing" };
@@ -18704,22 +19054,22 @@ async function syncDataQuery(client, id, body, reqOptions) {
   return out ?? {};
 }
 async function getAutoCalculateSettings(client, docId, reqOptions) {
-  const path11 = `/api/documents/${docId}/auto_calculate_settings`;
-  const res = await client.do("GET", path11, void 0, reqOptions);
+  const path12 = `/api/documents/${docId}/auto_calculate_settings`;
+  const res = await client.do("GET", path12, void 0, reqOptions);
   if (res.status === 404) {
     await res.text().catch(() => "");
     return null;
   }
   const text2 = await res.text();
   if (res.status < 200 || res.status >= 300) {
-    throw new Error(`GET ${path11}: HTTP ${res.status}: ${text2.slice(0, 200)}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}: ${text2.slice(0, 200)}`);
   }
   if (text2 === "" || text2 === '""') return null;
   try {
     return JSON.parse(text2);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`GET ${path11}: decode: ${msg}`);
+    throw new Error(`GET ${path12}: decode: ${msg}`);
   }
 }
 async function enableAutoCalculate(client, docId, reqOptions) {
@@ -19961,10 +20311,10 @@ function registerLutCommand(root) {
 
 // src/api/scans.ts
 async function getStatus(client, tableId, options) {
-  const path11 = `/api/scans/status/${tableId}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/scans/status/${tableId}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from scans status`);
+    throw new Error(`GET ${path12}: empty response from scans status`);
   }
   return out;
 }
@@ -20243,18 +20593,18 @@ async function list17(client, options) {
   return out ?? [];
 }
 async function get10(client, id, options) {
-  const path11 = `/api/exreports/reports/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/exreports/reports/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from reports get`);
+    throw new Error(`GET ${path12}: empty response from reports get`);
   }
   return out;
 }
 async function clone2(client, id, name, options) {
-  const path11 = `/api/exreports/reports/${id}/clone`;
-  const out = await client.postJSON(path11, { name }, options);
+  const path12 = `/api/exreports/reports/${id}/clone`;
+  const out = await client.postJSON(path12, { name }, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from reports clone`);
+    throw new Error(`POST ${path12}: empty response from reports clone`);
   }
   return out;
 }
@@ -20733,8 +21083,8 @@ async function loadDefinition(payloadFile, mutations) {
   }
   return out;
 }
-async function writeJsonFile(path11, value) {
-  await fs12.writeFile(path11, JSON.stringify(value, null, 2) + "\n", "utf8");
+async function writeJsonFile(path12, value) {
+  await fs12.writeFile(path12, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
 function designSummary(def) {
   const design = typeof def.options?.design === "string" ? def.options.design : "-";
@@ -21059,8 +21409,8 @@ function registerBudgetBuilderCommand(root) {
 
 // src/api/dataflow.ts
 async function get11(client, templateId, options) {
-  const path11 = `/api/dataflow/${templateId}/data`;
-  const out = await client.putJSON(path11, {}, options);
+  const path12 = `/api/dataflow/${templateId}/data`;
+  const out = await client.putJSON(path12, {}, options);
   return out ?? [];
 }
 
@@ -21189,8 +21539,8 @@ function registerDataflowCommand(root) {
 
 // src/api/metrics.ts
 async function listSemantic(client, options) {
-  const path11 = "/finance-os/api/metrics/v1/semantic_list";
-  const out = await client.getJSON(path11, options);
+  const path12 = "/finance-os/api/metrics/v1/semantic_list";
+  const out = await client.getJSON(path12, options);
   if (out === null) {
     return {
       success: true,
@@ -21201,23 +21551,23 @@ async function listSemantic(client, options) {
   return out;
 }
 async function listRaw2(client, options) {
-  const path11 = "/finance-os/api/metrics/v1/";
-  const out = await client.getJSON(path11, options);
+  const path12 = "/finance-os/api/metrics/v1/";
+  const out = await client.getJSON(path12, options);
   if (out === null) {
     return { success: true, data: [], error: null };
   }
   return out;
 }
 async function get12(client, id, options) {
-  const path11 = `/finance-os/api/metrics/v1/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/finance-os/api/metrics/v1/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from metrics get`);
+    throw new Error(`GET ${path12}: empty response from metrics get`);
   }
   return out;
 }
 async function getData2(client, params, options) {
-  const path11 = "/finance-os/api/metrics/v1/data";
+  const path12 = "/finance-os/api/metrics/v1/data";
   const body = {
     metric_ids: params.metric_ids,
     aggregation_period: params.aggregation_period,
@@ -21238,14 +21588,14 @@ async function getData2(client, params, options) {
   if (params.dimension_filters !== void 0 && Object.keys(params.dimension_filters).length > 0) {
     body["dimension_filters"] = params.dimension_filters;
   }
-  const out = await client.postJSON(path11, body, options);
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from metrics data`);
+    throw new Error(`POST ${path12}: empty response from metrics data`);
   }
   return out;
 }
 async function drilldown2(client, params, options) {
-  const path11 = "/finance-os/api/metrics/v1/drill_down";
+  const path12 = "/finance-os/api/metrics/v1/drill_down";
   const body = {
     metric_ids: params.metric_ids
   };
@@ -21259,12 +21609,12 @@ async function drilldown2(client, params, options) {
     body["dimension_filters"] = params.dimension_filters;
   }
   const out = await client.postJSON(
-    path11,
+    path12,
     body,
     options
   );
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from metrics drilldown`);
+    throw new Error(`POST ${path12}: empty response from metrics drilldown`);
   }
   return out;
 }
@@ -21298,7 +21648,7 @@ function parseDimensionFilters(raw) {
 }
 
 // src/commands/metricsCreate.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/api/metricsMonolith.ts
 async function create9(client, body, options) {
@@ -21434,9 +21784,9 @@ async function listDimensions(client, params, options) {
   if (params?.metric !== void 0) {
     qs.push(`metric=${params.metric}`);
   }
-  const path11 = qs.length > 0 ? `/api/insights/dimensions?${qs.join("&")}` : "/api/insights/dimensions";
+  const path12 = qs.length > 0 ? `/api/insights/dimensions?${qs.join("&")}` : "/api/insights/dimensions";
   const out = await client.getJSON(
-    path11,
+    path12,
     options
   );
   return unwrapList(out);
@@ -21893,34 +22243,34 @@ function reAggregateFailureMessage(progress, outcome, waitedSec) {
 
 // src/api/suggestions.ts
 async function listMetricSuggestions(client, options) {
-  const path11 = "/api/insights/metric_suggestions";
-  const out = await client.getJSON(path11, options);
+  const path12 = "/api/insights/metric_suggestions";
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response (expected {suggestions, dismissed, last_run})`);
+    throw new Error(`GET ${path12}: empty response (expected {suggestions, dismissed, last_run})`);
   }
   return out;
 }
 async function refreshMetricSuggestions(client, options) {
-  const path11 = "/api/insights/metric_suggestions/refresh";
-  const out = await client.postJSON(path11, {}, options);
+  const path12 = "/api/insights/metric_suggestions/refresh";
+  const out = await client.postJSON(path12, {}, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response (expected 202 with {run_id})`);
+    throw new Error(`POST ${path12}: empty response (expected 202 with {run_id})`);
   }
   return out;
 }
 async function listDimensionSuggestions(client, options) {
-  const path11 = "/api/insights/dimension_suggestions";
-  const out = await client.getJSON(path11, options);
+  const path12 = "/api/insights/dimension_suggestions";
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response (expected {suggestions, dismissed, last_run})`);
+    throw new Error(`GET ${path12}: empty response (expected {suggestions, dismissed, last_run})`);
   }
   return out;
 }
 async function refreshDimensionSuggestions(client, options) {
-  const path11 = "/api/insights/dimension_suggestions/refresh";
-  const out = await client.postJSON(path11, {}, options);
+  const path12 = "/api/insights/dimension_suggestions/refresh";
+  const out = await client.postJSON(path12, {}, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response (expected 202 with {run_id})`);
+    throw new Error(`POST ${path12}: empty response (expected 202 with {run_id})`);
   }
   return out;
 }
@@ -21950,71 +22300,6 @@ async function mapWithConcurrency(items, concurrency, task) {
   return results;
 }
 
-// src/commands/_retry.ts
-var AMBIGUOUS_STATUSES = /* @__PURE__ */ new Set([502, 504, 524]);
-var MAX_BACKOFF_MS = 8e3;
-function isAbortError(err) {
-  if (typeof err !== "object" || err === null) return false;
-  const name = err.name;
-  if (name === "AbortError" || name === "TimeoutError") return true;
-  return err.code === "ABORT_ERR";
-}
-function httpStatusOf(err) {
-  const msg = err instanceof Error ? err.message : String(err);
-  const m = /\bHTTP (\d{3})\b/.exec(msg);
-  return m === null ? void 0 : Number(m[1]);
-}
-function classifyFailure(err) {
-  if (isAbortError(err)) return "abort";
-  const status2 = httpStatusOf(err);
-  if (status2 === void 0) return "transient";
-  if (AMBIGUOUS_STATUSES.has(status2)) return "ambiguous";
-  if (status2 === 429) return "transient";
-  if (status2 >= 400 && status2 < 500) return "client";
-  return "transient";
-}
-function defaultBackoffMs(failedAttempt) {
-  return Math.min(1e3 * 2 ** (failedAttempt - 1), MAX_BACKOFF_MS);
-}
-async function sleep2(ms, signal) {
-  if (ms <= 0) return;
-  if (signal?.aborted === true) throw abortErrorFor(signal);
-  await new Promise((resolve3, reject) => {
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve3();
-    }, ms);
-    function onAbort() {
-      clearTimeout(timer);
-      reject(abortErrorFor(signal));
-    }
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function abortErrorFor(signal) {
-  const reason = signal?.reason;
-  if (reason instanceof Error) return reason;
-  return Object.assign(new Error("This operation was aborted"), {
-    name: "AbortError"
-  });
-}
-async function retryAsync(fn, opts) {
-  const retries = Number.isFinite(opts.retries) ? Math.max(0, Math.floor(opts.retries)) : 0;
-  for (let attempt = 1; ; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      const kind = classifyFailure(err);
-      const retryable = kind === "transient" || kind !== "abort" && opts.alsoRetry?.(err) === true;
-      if (!retryable || attempt > retries) throw err;
-      const delay = opts.delayMs ?? defaultBackoffMs;
-      const waitMs = typeof delay === "function" ? delay(attempt) : delay;
-      opts.onRetry?.(attempt, err, waitMs);
-      await sleep2(waitMs, opts.signal);
-    }
-  }
-}
-
 // src/commands/_fieldScreens.ts
 var SYSTEM_CATEGORY = "system";
 var SYSTEM_FIELD_NAMES = [
@@ -22712,9 +22997,9 @@ async function fetchRowCounts(client, tables, concurrency, opts, retryDelayMs) {
   }
   return { counts, unavailable, failures };
 }
-async function writeOwnerOnly(path11, contents) {
-  await writeFile2(path11, contents, { encoding: "utf8", mode: 384 });
-  if (process.platform !== "win32") await chmod2(path11, 384);
+async function writeOwnerOnly(path12, contents) {
+  await writeFile2(path12, contents, { encoding: "utf8", mode: 384 });
+  if (process.platform !== "win32") await chmod2(path12, 384);
 }
 function errText(e) {
   return (e instanceof Error ? e.message : String(e)).replace(/\s+/g, " ").trim();
@@ -22806,20 +23091,20 @@ function parseSuppressionDimension(d, source, i) {
   });
   return { name, mappings };
 }
-async function loadSuppression(path11) {
+async function loadSuppression(path12) {
   let text2;
   try {
-    text2 = await readFile2(path11, "utf8");
+    text2 = await readFile2(path12, "utf8");
   } catch (err) {
-    throw new Error(`--suppression: cannot read ${path11} (${errText(err)})`);
+    throw new Error(`--suppression: cannot read ${path12} (${errText(err)})`);
   }
   let parsed2;
   try {
     parsed2 = JSON.parse(text2);
   } catch (err) {
-    throw new Error(`--suppression: ${path11} is not valid JSON (${errText(err)})`);
+    throw new Error(`--suppression: ${path12} is not valid JSON (${errText(err)})`);
   }
-  return parseSuppression(parsed2, path11);
+  return parseSuppression(parsed2, path12);
 }
 async function runDimensionSuggestionsProfile(cfg) {
   const now = cfg.now ?? Date.now;
@@ -24749,14 +25034,14 @@ async function runMetricsDelete(cfg) {
     }
   });
 }
-function shortHash(input) {
-  return createHash4("sha256").update(input).digest("hex").slice(0, 12);
+function shortHash2(input) {
+  return createHash5("sha256").update(input).digest("hex").slice(0, 12);
 }
 function buildMetricsBatchDeleteAction(ids) {
   const sorted = [...new Set(ids)].sort((a, b) => a - b);
   return {
     resource: "metrics-batch",
-    id: shortHash(sorted.join(",")),
+    id: shortHash2(sorted.join(",")),
     verb: "delete"
   };
 }
@@ -26499,17 +26784,17 @@ function registerMetricsCommand(root) {
 
 // src/api/fx.ts
 async function getRates(client, options) {
-  const path11 = "/finance-os/api/foreign_exchange/v1/currency-rates";
-  const out = await client.getJSON(path11, options);
+  const path12 = "/finance-os/api/foreign_exchange/v1/currency-rates";
+  const out = await client.getJSON(path12, options);
   if (out === null) {
     return { base_currency: "", date: null, rates: {} };
   }
   return out;
 }
-async function fetchCurrencyList(client, path11, options) {
+async function fetchCurrencyList(client, path12, options) {
   let out;
   try {
-    out = await client.getJSON(path11, options);
+    out = await client.getJSON(path12, options);
   } catch (err) {
     if (isNotFoundError(err)) return [];
     throw err;
@@ -26563,7 +26848,7 @@ async function getOrgReportingCurrencies(client, organizationId, options) {
 }
 
 // src/commands/fxConfig.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 
 // src/api/widgets.ts
 async function list18(client, dashboardId, options) {
@@ -26578,18 +26863,18 @@ async function listRaw3(client, dashboardId, options) {
   return out ?? [];
 }
 async function create10(client, dashboardId, body, options) {
-  const path11 = `/api/dashboards/${dashboardId}/widgets`;
-  const out = await client.postJSON(path11, body, options);
+  const path12 = `/api/dashboards/${dashboardId}/widgets`;
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from widget create`);
+    throw new Error(`POST ${path12}: empty response from widget create`);
   }
   return out;
 }
 async function update6(client, dashboardId, id, body, options) {
-  const path11 = `/api/dashboards/${dashboardId}/widgets/${id}`;
-  const out = await client.putJSON(path11, body, options);
+  const path12 = `/api/dashboards/${dashboardId}/widgets/${id}`;
+  const out = await client.putJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`PUT ${path11}: empty response from widget update`);
+    throw new Error(`PUT ${path12}: empty response from widget update`);
   }
   return out;
 }
@@ -26597,10 +26882,10 @@ async function deleteById10(client, dashboardId, id, options) {
   await client.deleteJSON(`/api/dashboards/${dashboardId}/widgets/${id}`, options);
 }
 async function getTemplateFields(client, templateId, options) {
-  const path11 = `/api/templates/${templateId}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/templates/${templateId}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from template fetch`);
+    throw new Error(`GET ${path12}: empty response from template fetch`);
   }
   const fields = Array.isArray(out.fields) ? out.fields : [];
   const result = [];
@@ -26622,11 +26907,6 @@ async function putDataWithPolling(client, dashboardId, id, payload, options = {}
   );
 }
 
-// src/commands/_shellQuote.ts
-function shellQuote(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-
 // src/commands/_fxCurrencies.ts
 var FX_CURRENCY_SYMBOLS = /* @__PURE__ */ new Map([
   ["AED", "\u062F.\u0625"],
@@ -27056,7 +27336,7 @@ async function runFxSetPosting(cfg) {
     verb: "set-fx"
   } : {
     resource: "field-batch",
-    id: createHash5("sha256").update(
+    id: createHash6("sha256").update(
       changes.map((c) => `${c.field.id}:posting`).slice().sort().join("|")
     ).digest("hex").slice(0, 12),
     verb: "set-fx"
@@ -27510,7 +27790,7 @@ function buildSetReportingAction(changes) {
     };
   }
   const canonical = changes.map((c) => `${c.field.id}:reporting:${c.code}:${c.symbol ?? ""}`).slice().sort().join("|");
-  const sha = createHash5("sha256").update(canonical).digest("hex").slice(0, 12);
+  const sha = createHash6("sha256").update(canonical).digest("hex").slice(0, 12);
   return { resource: "field-batch", id: sha, verb: "set-fx" };
 }
 function renderReportingOutcome(out, results, skipped, notFxTables, asJson) {
@@ -28490,9 +28770,9 @@ function registerFxCommand(root) {
 }
 
 // src/commands/errorEnrichments.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { promises as fs13 } from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 
 // src/api/errorEnrichments.ts
 var BASE = "/api/v3/data_integrations/error-enrichments/";
@@ -28553,12 +28833,12 @@ async function stats(client, filters, options) {
   return out;
 }
 async function exportCsv(client, options) {
-  const path11 = `${BASE}export-csv/`;
-  const res = await client.do("GET", path11, void 0, options);
+  const path12 = `${BASE}export-csv/`;
+  const res = await client.do("GET", path12, void 0, options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`GET ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}: ${truncated}`);
   }
   return res.text();
 }
@@ -29001,7 +29281,7 @@ async function runEnrichmentsExport(cfg) {
   }
   if (!single && outPath !== void 0) {
     for (const s of cfg.servers) {
-      await fs13.rm(path4.join(outPath, `${s}.csv`), { force: true });
+      await fs13.rm(path5.join(outPath, `${s}.csv`), { force: true });
     }
   }
   const results = await sweep(
@@ -29021,7 +29301,7 @@ async function runEnrichmentsExport(cfg) {
       cfg.out.write(csv);
       continue;
     }
-    const dest = single ? outPath : path4.join(outPath, `${r.server}.csv`);
+    const dest = single ? outPath : path5.join(outPath, `${r.server}.csv`);
     await fs13.writeFile(dest, csv, "utf8");
     const rows = csvRowCount(csv);
     cfg.out.write(`Wrote ${rows} rule${plural(rows)} to ${dest}
@@ -29029,8 +29309,8 @@ async function runEnrichmentsExport(cfg) {
   }
   requireSweepSuccess(results);
 }
-function shortHash2(input) {
-  return createHash6("sha256").update(input).digest("hex").slice(0, 12);
+function shortHash3(input) {
+  return createHash7("sha256").update(input).digest("hex").slice(0, 12);
 }
 function canonicalBatch(parts) {
   return stableJson(parts);
@@ -29052,7 +29332,7 @@ function buildCreateAction(rules, fromArrayPayload) {
   }
   return {
     resource: "error-enrichment-batch",
-    id: shortHash2(canonicalBatch(rules.map(stableJson).sort())),
+    id: shortHash3(canonicalBatch(rules.map(stableJson).sort())),
     verb: "create"
   };
 }
@@ -29064,7 +29344,7 @@ function buildUpdateAction(patches, mode) {
   const entries = patches.map((p) => ({ id: p.id, json: stableJson(p.patch) })).sort((a, b) => a.id - b.id || (a.json < b.json ? -1 : a.json > b.json ? 1 : 0));
   return {
     resource: "error-enrichment-batch",
-    id: shortHash2(canonicalBatch(entries)),
+    id: shortHash3(canonicalBatch(entries)),
     verb: "update"
   };
 }
@@ -29075,7 +29355,7 @@ function buildDeleteAction(ids) {
   }
   return {
     resource: "error-enrichment-batch",
-    id: shortHash2(canonicalBatch(unique)),
+    id: shortHash3(canonicalBatch(unique)),
     verb: "delete"
   };
 }
@@ -29316,7 +29596,7 @@ async function runEnrichmentsImport(cfg) {
   await preflightConfirmToken(action, cfg.token);
   const csv = await fs13.readFile(cfg.file, "utf8");
   const csvRows = csv === "" ? 0 : Math.max(csv.trimEnd().split("\n").length - 1, 0);
-  const filename = path4.basename(cfg.file);
+  const filename = path5.basename(cfg.file);
   await twoStepConfirm({
     out: cfg.out,
     action,
@@ -29825,25 +30105,25 @@ function registerErrorEnrichmentsCommand(root) {
 }
 
 // src/commands/skill.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { readFile as readFile3, mkdir as mkdir2, readdir as readdir2, rm as rm2, rmdir, stat, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname6, join as join8, resolve as resolve2 } from "path";
+import { dirname as dirname6, join as join9, resolve as resolve2 } from "path";
 
 // src/commands/_skillsRoot.ts
 import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { basename as basename3, dirname as dirname5, join as join7 } from "path";
+import { basename as basename3, dirname as dirname5, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var PLUGIN_ONLY_MARKER = ".plugin-only";
 var PLUGIN_MAP_FILE = "plugins.json";
 var ROUTER_FILE = "SKILL.md";
 function skillRootSearchPaths(here = dirname5(fileURLToPath2(import.meta.url))) {
-  return { bundled: join7(here, "skills"), plugins: join7(here, "..", "..", "plugins") };
+  return { bundled: join8(here, "skills"), plugins: join8(here, "..", "..", "plugins") };
 }
 function skillRoots(here = dirname5(fileURLToPath2(import.meta.url))) {
   const { bundled, plugins } = skillRootSearchPaths(here);
   if (isDir(bundled)) return [bundled];
   if (!isDir(plugins)) return [];
-  return readdirSync(plugins, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join7(plugins, e.name, "skills")).filter(isDir).sort();
+  return readdirSync(plugins, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join8(plugins, e.name, "skills")).filter(isDir).sort();
 }
 function skillDirs(roots = skillRoots()) {
   const seen = /* @__PURE__ */ new Map();
@@ -29852,9 +30132,9 @@ function skillDirs(roots = skillRoots()) {
     const map = readPluginMap(root);
     for (const entry of readdirSync(root, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const dir = join7(root, entry.name);
-      if (existsSync(join7(dir, PLUGIN_ONLY_MARKER))) continue;
-      if (!isFile(join7(dir, ROUTER_FILE))) continue;
+      const dir = join8(root, entry.name);
+      if (existsSync(join8(dir, PLUGIN_ONLY_MARKER))) continue;
+      if (!isFile(join8(dir, ROUTER_FILE))) continue;
       const previous = seen.get(entry.name);
       if (previous !== void 0) {
         throw new Error(`duplicate skill name "${entry.name}": ${previous} and ${dir}`);
@@ -29874,12 +30154,12 @@ function pluginOf(root, name, map) {
   if (map === null) return basename3(dirname5(root));
   const plugin = map.get(name);
   if (plugin === void 0) {
-    throw new Error(`${join7(root, PLUGIN_MAP_FILE)} names no plugin for skill "${name}"`);
+    throw new Error(`${join8(root, PLUGIN_MAP_FILE)} names no plugin for skill "${name}"`);
   }
   return plugin;
 }
 function readPluginMap(root) {
-  const file = join7(root, PLUGIN_MAP_FILE);
+  const file = join8(root, PLUGIN_MAP_FILE);
   if (!existsSync(file)) return null;
   const parsed2 = JSON.parse(readFileSync2(file, "utf8"));
   const map = /* @__PURE__ */ new Map();
@@ -29921,7 +30201,7 @@ async function readSkillFiles(skillRoot) {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const e of entries) {
       if (isIgnoredSkillEntry(e.name)) continue;
-      const childAbs = join8(dir, e.name);
+      const childAbs = join9(dir, e.name);
       const childRel = prefix === "" ? e.name : `${prefix}/${e.name}`;
       if (e.isDirectory()) {
         await walk(childAbs, childRel);
@@ -29987,7 +30267,7 @@ async function runSkillPrint(cfg) {
     throw new Error(`skill "${skill.name}" has no file "${relPath}" \u2014 available: ${available}`);
   }
   if (cfg.hash) {
-    const hex = createHash7("sha256").update(hit.bytes).digest("hex");
+    const hex = createHash8("sha256").update(hit.bytes).digest("hex");
     cfg.out.write(hex + "\n");
     return;
   }
@@ -30003,26 +30283,26 @@ function relSegments(relPath) {
   return segs;
 }
 function skillDirAbs(targetAbs, dotDir, name) {
-  return join8(targetAbs, dotDir, "skills", name);
+  return join9(targetAbs, dotDir, "skills", name);
 }
 var MANIFEST_FILE = ".dr-cli-manifest.json";
 var MARKER_BEGIN = "<!-- dr-cli:begin -->";
 var MARKER_END = "<!-- dr-cli:end -->";
 var USERSPACE_ENV = "DR_CLI_USERSPACE_SKILLS";
 var DESKTOP_APP_DIRS = [
-  join8("AppData", "Roaming", "Claude"),
-  join8("Library", "Application Support", "Claude"),
-  join8(".config", "Claude")
+  join9("AppData", "Roaming", "Claude"),
+  join9("Library", "Application Support", "Claude"),
+  join9(".config", "Claude")
 ];
 function desktopAppDirs(targetAbs, env) {
-  const dirs = DESKTOP_APP_DIRS.map((d) => join8(targetAbs, d));
+  const dirs = DESKTOP_APP_DIRS.map((d) => join9(targetAbs, d));
   const appData = env["APPDATA"];
   const userHome = env["USERPROFILE"] ?? env["HOME"];
   if (appData === void 0 || appData === "" || userHome === void 0 || userHome === "")
     return dirs;
   const same = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
   if (!same(resolve2(userHome), targetAbs)) return dirs;
-  const redirected = join8(resolve2(appData), "Claude");
+  const redirected = join9(resolve2(appData), "Claude");
   return dirs.some((d) => same(d, redirected)) ? dirs : [...dirs, redirected];
 }
 async function registryPluginNames(file) {
@@ -30059,14 +30339,14 @@ async function pluginRegistries(targetAbs, env) {
     const names = await read(file);
     if (names !== null) found.push({ file, names });
   };
-  await add3(join8(targetAbs, ".claude", "plugins", "installed_plugins.json"), registryPluginNames);
+  await add3(join9(targetAbs, ".claude", "plugins", "installed_plugins.json"), registryPluginNames);
   for (const appDir of desktopAppDirs(targetAbs, env)) {
-    const sessions = join8(appDir, "local-agent-mode-sessions");
+    const sessions = join9(appDir, "local-agent-mode-sessions");
     for (const account of await subdirs(sessions)) {
-      for (const org of await subdirs(join8(sessions, account))) {
-        const base = join8(sessions, account, org);
-        await add3(join8(base, "rpm", "manifest.json"), desktopManifestPluginNames);
-        await add3(join8(base, "cowork_plugins", "installed_plugins.json"), registryPluginNames);
+      for (const org of await subdirs(join9(sessions, account))) {
+        const base = join9(sessions, account, org);
+        await add3(join9(base, "rpm", "manifest.json"), desktopManifestPluginNames);
+        await add3(join9(base, "cowork_plugins", "installed_plugins.json"), registryPluginNames);
       }
     }
   }
@@ -30110,7 +30390,7 @@ async function runSkillInstall(cfg) {
   const probe = await pluginManagedProbe(abs, cfg.env);
   if (probe.managed && !(cfg.force ?? false)) {
     cfg.out.write(
-      `Skipped ${join8(abs, ".claude", "skills")}: this machine gets the dr-cli skills from the dr-cli plugin (${probe.reason}). Pass --force to write them anyway.
+      `Skipped ${join9(abs, ".claude", "skills")}: this machine gets the dr-cli skills from the dr-cli plugin (${probe.reason}). Pass --force to write them anyway.
 `
     );
     for (const s of skills) {
@@ -30137,7 +30417,7 @@ async function runSkillInstall(cfg) {
   await maybeInstallToGemini(abs, skills, cfg.out, verbose);
 }
 async function maybeInstallToGemini(targetAbs, skills, out, verbose) {
-  const geminiDir = join8(targetAbs, ".gemini");
+  const geminiDir = join9(targetAbs, ".gemini");
   try {
     const st = await stat(geminiDir);
     if (!st.isDirectory()) {
@@ -30156,9 +30436,9 @@ async function maybeInstallToGemini(targetAbs, skills, out, verbose) {
       verbose,
       label: `Gemini skill ${s.name}`
     });
-    routerImportPaths.push(join8(skillDir, ...relSegments(ROUTER_FILE)));
+    routerImportPaths.push(join9(skillDir, ...relSegments(ROUTER_FILE)));
   }
-  const geminiMd = join8(geminiDir, "GEMINI.md");
+  const geminiMd = join9(geminiDir, "GEMINI.md");
   const block = renderImportBlock(routerImportPaths, "`dr skill install`");
   const { changed } = await updateMarkdownMarkerBlock(geminiMd, block);
   out.write(
@@ -30191,9 +30471,9 @@ async function runSkillInitProject(cfg) {
       verbose,
       label: `skill ${s.name}`
     });
-    routerSkillPaths.push(join8(skillDir, ...relSegments(ROUTER_FILE)));
+    routerSkillPaths.push(join9(skillDir, ...relSegments(ROUTER_FILE)));
   }
-  const geminiMd = join8(abs, "GEMINI.md");
+  const geminiMd = join9(abs, "GEMINI.md");
   const geminiBlock = renderImportBlock(routerSkillPaths, "`dr skill init-project`");
   const { changed: geminiChanged } = await updateMarkdownMarkerBlock(geminiMd, geminiBlock);
   cfg.out.write(
@@ -30201,7 +30481,7 @@ async function runSkillInitProject(cfg) {
 ` : `Gemini imports already registered \u2014 no change: ${geminiMd}
 `
   );
-  const agentsMd = join8(abs, "AGENTS.md");
+  const agentsMd = join9(abs, "AGENTS.md");
   const agentsBlock = renderInlineBlock(skills, "`dr skill init-project`", ".dr-cli/skills");
   const agentsBytes = Buffer.byteLength(agentsBlock, "utf8");
   if (agentsBytes > AGENTS_WARN_BYTES) {
@@ -30241,7 +30521,7 @@ async function writeOneFile(targetPath, bytes) {
 }
 async function readManifest(skillDir) {
   try {
-    const raw = await readFile3(join8(skillDir, MANIFEST_FILE), "utf8");
+    const raw = await readFile3(join9(skillDir, MANIFEST_FILE), "utf8");
     const parsed2 = JSON.parse(raw);
     const files = parsed2.files;
     return Array.isArray(files) ? files.filter((x) => typeof x === "string") : [];
@@ -30250,7 +30530,7 @@ async function readManifest(skillDir) {
   }
 }
 async function removeUserSpaceCopy(skillDir) {
-  const manifestPath = join8(skillDir, MANIFEST_FILE);
+  const manifestPath = join9(skillDir, MANIFEST_FILE);
   try {
     await stat(manifestPath);
   } catch {
@@ -30259,7 +30539,7 @@ async function removeUserSpaceCopy(skillDir) {
   let files = 0;
   for (const rel of await readManifest(skillDir)) {
     try {
-      const p = join8(skillDir, ...relSegments(rel));
+      const p = join9(skillDir, ...relSegments(rel));
       await rm2(p, { force: true });
       await rmdir(dirname6(p)).catch(() => {
       });
@@ -30281,7 +30561,7 @@ async function installSkillTree(opts) {
   let unchanged = 0;
   let totalBytes = 0;
   for (const f of files) {
-    const targetPath = join8(skillDir, ...relSegments(f.relPath));
+    const targetPath = join9(skillDir, ...relSegments(f.relPath));
     const status2 = await writeOneFile(targetPath, f.bytes);
     totalBytes += f.bytes.length;
     if (status2 === "installed") {
@@ -30303,7 +30583,7 @@ async function installSkillTree(opts) {
   const current = new Set(files.map((f) => f.relPath));
   await mkdir2(skillDir, { recursive: true, mode: 493 });
   await writeFile3(
-    join8(skillDir, MANIFEST_FILE),
+    join9(skillDir, MANIFEST_FILE),
     JSON.stringify({ files: [...current].sort() }) + "\n",
     {
       mode: 420
@@ -30313,7 +30593,7 @@ async function installSkillTree(opts) {
   for (const oldRel of prev) {
     if (current.has(oldRel)) continue;
     try {
-      const p = join8(skillDir, ...relSegments(oldRel));
+      const p = join9(skillDir, ...relSegments(oldRel));
       await rm2(p, { force: true });
       await rmdir(dirname6(p)).catch(() => {
       });
@@ -30461,26 +30741,26 @@ async function listFull(client, tableId, options) {
   return out ?? [];
 }
 async function get14(client, tableId, id, options) {
-  const path11 = `/api/templates/${tableId}/mappers/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/templates/${tableId}/mappers/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from datamapper get`);
+    throw new Error(`GET ${path12}: empty response from datamapper get`);
   }
   return out;
 }
 async function getDetails2(client, id, options) {
-  const path11 = `/api/templates/mappers/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/templates/mappers/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from datamapper details`);
+    throw new Error(`GET ${path12}: empty response from datamapper details`);
   }
   return out;
 }
 async function create12(client, tableId, body, options) {
-  const path11 = `/api/templates/${tableId}/mappers`;
-  const out = await client.postJSON(path11, body, options);
+  const path12 = `/api/templates/${tableId}/mappers`;
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from datamapper create`);
+    throw new Error(`POST ${path12}: empty response from datamapper create`);
   }
   return out;
 }
@@ -30492,14 +30772,14 @@ async function listCustomFunctions(client, options) {
   return out ?? [];
 }
 async function previewData(client, body, options) {
-  const path11 = "/api/templates/preview-data";
-  return client.postJSON(path11, body, options);
+  const path12 = "/api/templates/preview-data";
+  return client.postJSON(path12, body, options);
 }
 async function updateBinding(client, mapperId, body, options) {
-  const path11 = `/api/templates/mappers/${mapperId}/binding`;
-  const out = await client.postJSON(path11, body, options);
+  const path12 = `/api/templates/mappers/${mapperId}/binding`;
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from datamapper binding update`);
+    throw new Error(`POST ${path12}: empty response from datamapper binding update`);
   }
   return out;
 }
@@ -30710,12 +30990,12 @@ function formatCalcFieldError(name, preview2, full) {
 // src/commands/_errorLog.ts
 import { promises as fs14 } from "fs";
 import * as os3 from "os";
-import * as path5 from "path";
+import * as path6 from "path";
 var RESPONSE_BODY_MAX_BYTES = 8 * 1024;
 async function writeErrorLog(opts) {
   const filename = `dr-cli-error-${timestampStamp()}.md`;
   const dir = await chooseDir(opts.dirOverride);
-  const filePath = path5.join(dir, filename);
+  const filePath = path6.join(dir, filename);
   const md = formatLog(opts);
   await fs14.writeFile(filePath, md, { encoding: "utf8" });
   return filePath;
@@ -31454,11 +31734,11 @@ function buildCoordEntries(pairs, role) {
   });
 }
 async function readSheetHeaders(client, docId, versionId, sheet, signal) {
-  const path11 = `/api/documents/${docId}/versions/${versionId}/raw?start_row=1&end_row=1&data_only=false&sheet_ind=0&sheet_name=${rawQueryEscape(sheet)}&optimize=true`;
+  const path12 = `/api/documents/${docId}/versions/${versionId}/raw?start_row=1&end_row=1&data_only=false&sheet_ind=0&sheet_name=${rawQueryEscape(sheet)}&optimize=true`;
   let rows;
   try {
     const opts = signal === void 0 ? void 0 : { signal };
-    const got = await client.getJSON(path11, opts);
+    const got = await client.getJSON(path12, opts);
     rows = got ?? [];
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
@@ -32120,15 +32400,15 @@ async function list21(client, options) {
   return out ?? [];
 }
 async function get15(client, id, options) {
-  const path11 = `/api/mapper_recipients/mapper_templates/${id}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/mapper_recipients/mapper_templates/${id}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from mapper recipe get`);
+    throw new Error(`GET ${path12}: empty response from mapper recipe get`);
   }
   return out;
 }
 async function create13(client, args, options) {
-  const path11 = "/api/mapper_recipients/mapper_templates";
+  const path12 = "/api/mapper_recipients/mapper_templates";
   const body = {
     name: args.name,
     description: args.description,
@@ -32136,9 +32416,9 @@ async function create13(client, args, options) {
     config: JSON.stringify(args.config),
     fields_to_change: JSON.stringify(args.fields_to_change)
   };
-  const out = await client.postJSON(path11, body, options);
+  const out = await client.postJSON(path12, body, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from mapper recipe create`);
+    throw new Error(`POST ${path12}: empty response from mapper recipe create`);
   }
   return out;
 }
@@ -32324,7 +32604,7 @@ function parseFromVersion(s) {
 
 // src/commands/documents.ts
 import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import * as path6 from "path";
+import * as path7 from "path";
 
 // src/api/documentSplits.ts
 var SPLITS_PATH = "/api/documents/cycles/splits";
@@ -32337,15 +32617,15 @@ async function list22(client, query, options) {
     params.set("dimension_tags_value", query.dimensionTagsValue);
   }
   const qs = params.toString();
-  const path11 = qs === "" ? SPLITS_PATH : `${SPLITS_PATH}?${qs}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs === "" ? SPLITS_PATH : `${SPLITS_PATH}?${qs}`;
+  const out = await client.getJSON(path12, options);
   return out ?? [];
 }
 async function create14(client, payload, customTagId, options) {
-  const path11 = customTagId === void 0 ? SPLITS_PATH : `${SPLITS_PATH}?custom_tag_id=${customTagId}`;
-  const out = await client.postJSON(path11, payload, options);
+  const path12 = customTagId === void 0 ? SPLITS_PATH : `${SPLITS_PATH}?custom_tag_id=${customTagId}`;
+  const out = await client.postJSON(path12, payload, options);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from split create`);
+    throw new Error(`POST ${path12}: empty response from split create`);
   }
   return out;
 }
@@ -32353,10 +32633,10 @@ async function undo(client, splitId, options) {
   return client.putJSON(`/api/documents/cycles/split/${splitId}/undo`, {}, options);
 }
 async function status(client, splitId, options) {
-  const path11 = `/api/documents/document_split/${splitId}/status`;
-  const out = await client.getJSON(path11, options);
+  const path12 = `/api/documents/document_split/${splitId}/status`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from split status`);
+    throw new Error(`GET ${path12}: empty response from split status`);
   }
   return out;
 }
@@ -32802,7 +33082,7 @@ async function runDebugZip(cfg) {
 }
 async function runUploadPollDownload(core) {
   const buf = await readFile4(core.filePath);
-  const filename = path6.basename(core.filePath);
+  const filename = path7.basename(core.filePath);
   const start = await core.start(new Blob([buf]), filename);
   core.out.write(
     `Uploaded ${filename}; request ${String(start.requestId)} started \u2014 polling for the result\u2026
@@ -32815,8 +33095,8 @@ async function runUploadPollDownload(core) {
 `);
 }
 function defaultJobOutputPath(inputPath, suffix) {
-  const parsed2 = path6.parse(inputPath);
-  return path6.join(parsed2.dir, `${parsed2.name}${suffix}`);
+  const parsed2 = path7.parse(inputPath);
+  return path7.join(parsed2.dir, `${parsed2.name}${suffix}`);
 }
 async function runAutoCalculate(cfg) {
   await runUploadPollDownload({
@@ -33592,34 +33872,34 @@ import { Option as Option2 } from "commander";
 
 // src/api/integrations.ts
 async function list23(client, opts, reqOptions) {
-  let path11 = `/api/v3/data_integrations/?page=${opts.page}&page_size=${opts.pageSize}`;
+  let path12 = `/api/v3/data_integrations/?page=${opts.page}&page_size=${opts.pageSize}`;
   const s = (opts.search ?? "").trim();
   if (s !== "") {
-    path11 += `&search=${rawQueryEscape(s)}`;
+    path12 += `&search=${rawQueryEscape(s)}`;
   }
-  const out = await client.getJSON(path11, reqOptions);
+  const out = await client.getJSON(path12, reqOptions);
   return out ?? { count: 0, next: null, previous: null, results: [] };
 }
 async function getById2(client, id, reqOptions) {
-  const path11 = `/api/v3/data_integrations/${id}/`;
-  const out = await client.getJSON(path11, reqOptions);
+  const path12 = `/api/v3/data_integrations/${id}/`;
+  const out = await client.getJSON(path12, reqOptions);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from data_integrations get`);
+    throw new Error(`GET ${path12}: empty response from data_integrations get`);
   }
   return out;
 }
 async function getDataSourcesPage(client, page, reqOptions) {
-  const path11 = `/api/v3/data_integrations/data-sources?page=${page}`;
-  const out = await client.getJSON(path11, reqOptions);
+  const path12 = `/api/v3/data_integrations/data-sources?page=${page}`;
+  const out = await client.getJSON(path12, reqOptions);
   return out ?? { next: null, results: [] };
 }
 async function listTypes(client, search, reqOptions) {
-  let path11 = "/api/v3/data_integrations/types/";
+  let path12 = "/api/v3/data_integrations/types/";
   const s = (search ?? "").trim();
   if (s !== "") {
-    path11 += `?search=${rawQueryEscape(s)}`;
+    path12 += `?search=${rawQueryEscape(s)}`;
   }
-  const raw = await client.getJSON(path11, reqOptions);
+  const raw = await client.getJSON(path12, reqOptions);
   if (raw === null) return [];
   if (typeof raw === "object" && raw !== null && !Array.isArray(raw) && "results" in raw && Array.isArray(raw.results)) {
     return raw.results;
@@ -33627,7 +33907,7 @@ async function listTypes(client, search, reqOptions) {
   if (Array.isArray(raw)) {
     return raw;
   }
-  throw new Error(`GET ${path11}: unrecognized response shape`);
+  throw new Error(`GET ${path12}: unrecognized response shape`);
 }
 async function queryCheckStatus(client, queryIds, reqOptions) {
   const out = await client.putJSON(
@@ -33637,8 +33917,8 @@ async function queryCheckStatus(client, queryIds, reqOptions) {
   );
   return out ?? [];
 }
-async function getErrorExplanation(client, path11, reqOptions) {
-  const res = await client.do("GET", path11, void 0, reqOptions);
+async function getErrorExplanation(client, path12, reqOptions) {
+  const res = await client.do("GET", path12, void 0, reqOptions);
   const text2 = await res.text();
   if (res.status === 200) {
     let parsed2;
@@ -33675,18 +33955,18 @@ async function testConnection(client, rawBody, reqOptions) {
   return { status: res.status, rawText: text2 };
 }
 async function create15(client, body, reqOptions) {
-  const path11 = "/api/v3/data_integrations/";
-  const out = await client.postJSON(path11, body, reqOptions);
+  const path12 = "/api/v3/data_integrations/";
+  const out = await client.postJSON(path12, body, reqOptions);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from data_integrations create`);
+    throw new Error(`POST ${path12}: empty response from data_integrations create`);
   }
   return out;
 }
 async function update8(client, id, body, reqOptions) {
-  const path11 = `/api/v3/data_integrations/${id}/`;
-  const out = await client.putJSON(path11, body, reqOptions);
+  const path12 = `/api/v3/data_integrations/${id}/`;
+  const out = await client.putJSON(path12, body, reqOptions);
   if (out === null) {
-    throw new Error(`PUT ${path11}: empty response from data_integrations update`);
+    throw new Error(`PUT ${path12}: empty response from data_integrations update`);
   }
   return out;
 }
@@ -33746,43 +34026,43 @@ async function shareGroups(client, id, groupIds, reqOptions) {
   return { detail: typeof out.detail === "string" ? out.detail : null };
 }
 async function itList(client, opts, reqOptions) {
-  let path11 = `/api/it/integrations?page=${opts.page}&page_size=${opts.pageSize}`;
+  let path12 = `/api/it/integrations?page=${opts.page}&page_size=${opts.pageSize}`;
   const s = (opts.search ?? "").trim();
   if (s !== "") {
-    path11 += `&search=${rawQueryEscape(s)}`;
+    path12 += `&search=${rawQueryEscape(s)}`;
   }
-  const out = await client.getJSON(path11, reqOptions);
+  const out = await client.getJSON(path12, reqOptions);
   return out ?? { count: 0, next: null, previous: null, results: [] };
 }
 async function itGet(client, id, reqOptions) {
-  const path11 = `/api/it/integrations/${id}`;
-  const out = await client.getJSON(path11, reqOptions);
+  const path12 = `/api/it/integrations/${id}`;
+  const out = await client.getJSON(path12, reqOptions);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from it integrations get`);
+    throw new Error(`GET ${path12}: empty response from it integrations get`);
   }
   return out;
 }
 async function itGetRaw(client, id, reqOptions) {
-  const path11 = `/api/it/integrations/${id}`;
-  const out = await client.getJSON(path11, reqOptions);
+  const path12 = `/api/it/integrations/${id}`;
+  const out = await client.getJSON(path12, reqOptions);
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from it integrations get`);
+    throw new Error(`GET ${path12}: empty response from it integrations get`);
   }
   return out;
 }
 async function itCreate(client, body, reqOptions) {
-  const path11 = "/api/it/integrations";
-  const out = await client.postJSON(path11, body, reqOptions);
+  const path12 = "/api/it/integrations";
+  const out = await client.postJSON(path12, body, reqOptions);
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from it integrations create`);
+    throw new Error(`POST ${path12}: empty response from it integrations create`);
   }
   return out;
 }
 async function itUpdate(client, id, body, reqOptions) {
-  const path11 = `/api/it/integrations/${id}`;
-  const out = await client.putJSON(path11, body, reqOptions);
+  const path12 = `/api/it/integrations/${id}`;
+  const out = await client.putJSON(path12, body, reqOptions);
   if (out === null) {
-    throw new Error(`PUT ${path11}: empty response from it integrations update`);
+    throw new Error(`PUT ${path12}: empty response from it integrations update`);
   }
   return out;
 }
@@ -33802,7 +34082,7 @@ async function itResync(client, id, reqOptions) {
 // src/commands/filebox.ts
 import { promises as fsPromises, existsSync as existsSync2 } from "fs";
 import * as nodePath from "path";
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 
 // src/commands/filebox_admin.ts
 import { promises as fs15 } from "fs";
@@ -35044,11 +35324,11 @@ async function updateScenario(client, scenarioId, patch, options) {
   return out ?? {};
 }
 async function deleteScenario(client, scenarioId, opts = {}, options) {
-  let path11 = `/api/documents/cycles/${scenarioId}/custom_tags`;
+  let path12 = `/api/documents/cycles/${scenarioId}/custom_tags`;
   if (opts.documentId !== void 0) {
-    path11 += `?document_id=${opts.documentId}`;
+    path12 += `?document_id=${opts.documentId}`;
   }
-  await client.deleteJSON(path11, options);
+  await client.deleteJSON(path12, options);
 }
 async function bulkYearEdit(client, payload, options) {
   const out = await client.postJSON(
@@ -36431,7 +36711,7 @@ function buildIncludeBatchAction(docId, include, targets) {
   const canonical = `${docId}|${include ? "on" : "off"}|${targets.map((v) => v.id).slice().sort((a, b) => a - b).join(",")}`;
   return {
     resource: "filebox-version-batch",
-    id: createHash8("sha256").update(canonical).digest("hex").slice(0, 12),
+    id: createHash9("sha256").update(canonical).digest("hex").slice(0, 12),
     verb: includeStateWords(include).verb
   };
 }
@@ -39187,8 +39467,8 @@ async function runIntegrationsErrors(cfg) {
   if (cfg.id <= 0) {
     throw new Error("integration id must be positive");
   }
-  const path11 = cfg.queryId > 0 ? `/api/data_integrations/${cfg.queryId}/data_query/error_explanation` : `/api/data_integrations/${cfg.id}/data_source/error_explanation`;
-  const result = await getErrorExplanation(cfg.client, path11, {
+  const path12 = cfg.queryId > 0 ? `/api/data_integrations/${cfg.queryId}/data_query/error_explanation` : `/api/data_integrations/${cfg.id}/data_source/error_explanation`;
+  const result = await getErrorExplanation(cfg.client, path12, {
     signal: cfg.signal
   });
   if (result.status === 404 || result.body === null) {
@@ -40497,7 +40777,7 @@ function registerITCommands(parent) {
 
 // src/commands/connectors.ts
 import { execFile } from "child_process";
-import * as path8 from "path";
+import * as path9 from "path";
 import { promisify } from "util";
 
 // src/api/connectors.ts
@@ -40512,20 +40792,20 @@ var ControlPlaneError = class extends Error {
   }
 };
 async function ingestVersion(client, name, version, reqOptions) {
-  const path11 = `/connectors/${encodeURIComponent(name)}/ingest`;
+  const path12 = `/connectors/${encodeURIComponent(name)}/ingest`;
   let out;
   try {
-    out = await client.postJSON(path11, { version }, reqOptions);
+    out = await client.postJSON(path12, { version }, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("POST", path11, err);
+    throw toControlPlaneError("POST", path12, err);
   }
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from control-plane ingest`);
+    throw new Error(`POST ${path12}: empty response from control-plane ingest`);
   }
   return out;
 }
 async function createConnector(client, fields, reqOptions) {
-  const path11 = "/connectors";
+  const path12 = "/connectors";
   const body = {
     type: fields.type,
     secret_ref: fields.secret_ref,
@@ -40534,30 +40814,30 @@ async function createConnector(client, fields, reqOptions) {
   if (fields.org_id !== void 0) body["org_id"] = fields.org_id;
   let out;
   try {
-    out = await client.postJSON(path11, body, reqOptions);
+    out = await client.postJSON(path12, body, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("POST", path11, err);
+    throw toControlPlaneError("POST", path12, err);
   }
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from control-plane connector create`);
+    throw new Error(`POST ${path12}: empty response from control-plane connector create`);
   }
   return out;
 }
 async function createQuery(client, fields, reqOptions) {
-  const path11 = "/connector-queries";
+  const path12 = "/connector-queries";
   let out;
   try {
-    out = await client.postJSON(path11, fields, reqOptions);
+    out = await client.postJSON(path12, fields, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("POST", path11, err);
+    throw toControlPlaneError("POST", path12, err);
   }
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from control-plane query create`);
+    throw new Error(`POST ${path12}: empty response from control-plane query create`);
   }
   return out;
 }
 async function repointQuery(client, queryId, fields, reqOptions) {
-  const path11 = `/connector-queries/${queryId}`;
+  const path12 = `/connector-queries/${queryId}`;
   const body = {};
   if (fields.artifact_name !== void 0) body["artifact_name"] = fields.artifact_name;
   if (fields.artifact_version !== void 0) body["artifact_version"] = fields.artifact_version;
@@ -40567,66 +40847,66 @@ async function repointQuery(client, queryId, fields, reqOptions) {
   if (fields.query_config !== void 0) body["query_config"] = fields.query_config;
   let out;
   try {
-    out = await client.patchJSON(path11, body, reqOptions);
+    out = await client.patchJSON(path12, body, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("PATCH", path11, err);
+    throw toControlPlaneError("PATCH", path12, err);
   }
   if (out === null) {
-    throw new Error(`PATCH ${path11}: empty response from control-plane repoint`);
+    throw new Error(`PATCH ${path12}: empty response from control-plane repoint`);
   }
   return out;
 }
 async function getBinding(client, fileboxUuid, reqOptions) {
-  const path11 = `/internal/bindings/${encodeURIComponent(fileboxUuid)}`;
+  const path12 = `/internal/bindings/${encodeURIComponent(fileboxUuid)}`;
   let out;
   try {
-    out = await client.getJSON(path11, reqOptions);
+    out = await client.getJSON(path12, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("GET", path11, err);
+    throw toControlPlaneError("GET", path12, err);
   }
   if (out === null) {
-    throw new Error(`GET ${path11}: empty response from control-plane binding get`);
+    throw new Error(`GET ${path12}: empty response from control-plane binding get`);
   }
   return out;
 }
 async function listQueries(client, reqOptions) {
-  const path11 = "/connector-queries";
+  const path12 = "/connector-queries";
   try {
-    return await client.getJSON(path11, reqOptions) ?? [];
+    return await client.getJSON(path12, reqOptions) ?? [];
   } catch (err) {
-    throw toControlPlaneError("GET", path11, err);
+    throw toControlPlaneError("GET", path12, err);
   }
 }
 async function deleteQuery(client, queryId, reqOptions) {
-  const path11 = `/connector-queries/${queryId}`;
+  const path12 = `/connector-queries/${queryId}`;
   try {
-    await client.deleteJSON(path11, reqOptions);
+    await client.deleteJSON(path12, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("DELETE", path11, err);
+    throw toControlPlaneError("DELETE", path12, err);
   }
 }
 async function deregisterArtifact(client, name, version, reqOptions) {
-  const path11 = `/internal/artifacts/${encodeURIComponent(name)}/${encodeURIComponent(version)}`;
+  const path12 = `/internal/artifacts/${encodeURIComponent(name)}/${encodeURIComponent(version)}`;
   try {
-    await client.deleteJSON(path11, reqOptions);
+    await client.deleteJSON(path12, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("DELETE", path11, err);
+    throw toControlPlaneError("DELETE", path12, err);
   }
 }
 async function promoteActive(client, name, version, reqOptions) {
-  const path11 = `/connectors/${encodeURIComponent(name)}/active`;
+  const path12 = `/connectors/${encodeURIComponent(name)}/active`;
   try {
-    return await client.postJSON(path11, { version }, reqOptions);
+    return await client.postJSON(path12, { version }, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("POST", path11, err);
+    throw toControlPlaneError("POST", path12, err);
   }
 }
 async function resolveActive(client, name, orgId, reqOptions) {
-  const path11 = `/internal/connectors/${encodeURIComponent(name)}/active?org_id=${orgId}`;
+  const path12 = `/internal/connectors/${encodeURIComponent(name)}/active?org_id=${orgId}`;
   try {
-    return await client.getJSON(path11, reqOptions);
+    return await client.getJSON(path12, reqOptions);
   } catch (err) {
-    const e = toControlPlaneError("GET", path11, err);
+    const e = toControlPlaneError("GET", path12, err);
     if (e instanceof ControlPlaneError && e.status === 404) return null;
     throw e;
   }
@@ -40636,19 +40916,19 @@ async function cancelSync(client, fileboxUuid, target = {}, reqOptions) {
   if (target.mode !== void 0) query.set("mode", target.mode);
   if (target.dateTags !== void 0) query.set("date_tags", target.dateTags);
   const suffix = query.toString() === "" ? "" : `?${query.toString()}`;
-  const path11 = `/fileboxes/${encodeURIComponent(fileboxUuid)}/sync/cancel${suffix}`;
+  const path12 = `/fileboxes/${encodeURIComponent(fileboxUuid)}/sync/cancel${suffix}`;
   let out;
   try {
-    out = await client.postJSON(path11, {}, reqOptions);
+    out = await client.postJSON(path12, {}, reqOptions);
   } catch (err) {
-    throw toControlPlaneError("POST", path11, err);
+    throw toControlPlaneError("POST", path12, err);
   }
   if (out === null) {
-    throw new Error(`POST ${path11}: empty response from control-plane sync cancel`);
+    throw new Error(`POST ${path12}: empty response from control-plane sync cancel`);
   }
   return out;
 }
-function toControlPlaneError(method, path11, err) {
+function toControlPlaneError(method, path12, err) {
   const msg = err instanceof Error ? err.message : String(err);
   const m = /HTTP (\d{3})(?::\s*([\s\S]*))?$/.exec(msg);
   if (m === null) return err;
@@ -40657,13 +40937,13 @@ function toControlPlaneError(method, path11, err) {
   return new ControlPlaneError(
     status2,
     body,
-    `${method} ${path11}: HTTP ${status2}${body === "" ? "" : `: ${body}`}`
+    `${method} ${path12}: HTTP ${status2}${body === "" ? "" : `: ${body}`}`
   );
 }
 
 // src/commands/connectorsDevFetch.ts
 import { promises as fs16 } from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function buildDevEnvelope(i) {
   const config = {
@@ -40747,11 +41027,11 @@ async function writeRunDir(input) {
   }
   await fs16.mkdir(input.outDir, { recursive: true });
   await fs16.writeFile(
-    path7.join(input.outDir, ENV_FILE),
+    path8.join(input.outDir, ENV_FILE),
     JSON.stringify(input.env, null, 2) + "\n",
     "utf-8"
   );
-  const secretsPath = path7.join(input.outDir, SECRETS_FILE);
+  const secretsPath = path8.join(input.outDir, SECRETS_FILE);
   await fs16.writeFile(
     secretsPath,
     JSON.stringify({ [input.secretRef]: input.credentials }, null, 2) + "\n",
@@ -40760,11 +41040,11 @@ async function writeRunDir(input) {
   if (process.platform !== "win32") {
     await fs16.chmod(secretsPath, 384);
   }
-  await fs16.writeFile(path7.join(input.outDir, CONNECTION_FILE), connectionSource, "utf-8");
-  await fs16.writeFile(path7.join(input.outDir, QUERY_FILE), querySource, "utf-8");
+  await fs16.writeFile(path8.join(input.outDir, CONNECTION_FILE), connectionSource, "utf-8");
+  await fs16.writeFile(path8.join(input.outDir, QUERY_FILE), querySource, "utf-8");
 }
 async function ensureGitignored(entry) {
-  const gitignorePath = path7.join(process.cwd(), ".gitignore");
+  const gitignorePath = path8.join(process.cwd(), ".gitignore");
   let current = "";
   try {
     current = await fs16.readFile(gitignorePath, "utf-8");
@@ -40799,7 +41079,7 @@ function registerDevFetch(connectors) {
     if (opts.from === void 0 !== (opts.to === void 0)) {
       throw new Error("--from and --to must be provided together");
     }
-    const defaultRoot = path7.join("dev-run", fileboxUuid);
+    const defaultRoot = path8.join("dev-run", fileboxUuid);
     const outDir = opts.output ?? defaultRoot;
     const gitignoreEntry = opts.output ?? "dev-run";
     const serverKey = resolveServer(opts.server);
@@ -41072,7 +41352,7 @@ async function runPublish(cfg) {
     }
     version = cfg.tag;
   } else {
-    const cwd = path8.dirname(cfg.dataqueryFile) || ".";
+    const cwd = path9.dirname(cfg.dataqueryFile) || ".";
     const listTags3 = cfg.listTags ?? defaultListTags;
     const newest = newestVersion(await listTags3(cwd, prefix), prefix);
     if (newest === null) {
@@ -43274,7 +43554,7 @@ function registerWidgetsCommand(root) {
 }
 
 // src/commands/reconciliation.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { promises as fs18 } from "fs";
 
 // src/api/reconciliation.ts
@@ -43332,8 +43612,8 @@ async function getAccountSettings(client, params = {}, options) {
   if (params.entity !== void 0 && params.entity !== "") {
     qs.set("entity", params.entity);
   }
-  const path11 = qs.toString() === "" ? "/api/reconciliation/accounts/settings" : `/api/reconciliation/accounts/settings?${qs.toString()}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs.toString() === "" ? "/api/reconciliation/accounts/settings" : `/api/reconciliation/accounts/settings?${qs.toString()}`;
+  const out = await client.getJSON(path12, options);
   return out ?? [];
 }
 async function updateAccountSettings(client, payload, options) {
@@ -43386,8 +43666,8 @@ async function getProcessEvidences(client, params, options) {
   if (params.evidenceType !== void 0 && params.evidenceType !== "") {
     qs.set("evidence_type", params.evidenceType);
   }
-  const path11 = qs.toString() === "" ? `/api/reconciliation/processes/${params.processId}/evidences` : `/api/reconciliation/processes/${params.processId}/evidences?${qs.toString()}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs.toString() === "" ? `/api/reconciliation/processes/${params.processId}/evidences` : `/api/reconciliation/processes/${params.processId}/evidences?${qs.toString()}`;
+  const out = await client.getJSON(path12, options);
   return out ?? [];
 }
 async function createSupportingItem(client, params, file, filename, options) {
@@ -43417,17 +43697,17 @@ async function getProcessSupportingItems(client, params, options) {
   if (params.entity !== void 0 && params.entity !== "") {
     qs.set("entity", params.entity);
   }
-  const path11 = qs.toString() === "" ? `/api/reconciliation/processes/${params.processId}/supporting_items` : `/api/reconciliation/processes/${params.processId}/supporting_items?${qs.toString()}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs.toString() === "" ? `/api/reconciliation/processes/${params.processId}/supporting_items` : `/api/reconciliation/processes/${params.processId}/supporting_items?${qs.toString()}`;
+  const out = await client.getJSON(path12, options);
   return out ?? [];
 }
 async function getEvidenceFile(client, params, options) {
-  const path11 = params.accountId !== void 0 && params.accountId !== "" ? `/api/reconciliation/processes/${params.processId}/account/${params.accountId}/evidences/${params.evidenceId}/file` : `/api/reconciliation/processes/${params.processId}/evidences/${params.evidenceId}/file`;
-  const res = await client.do("GET", path11, void 0, options);
+  const path12 = params.accountId !== void 0 && params.accountId !== "" ? `/api/reconciliation/processes/${params.processId}/account/${params.accountId}/evidences/${params.evidenceId}/file` : `/api/reconciliation/processes/${params.processId}/evidences/${params.evidenceId}/file`;
+  const res = await client.do("GET", path12, void 0, options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`GET ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`GET ${path12}: HTTP ${res.status}: ${truncated}`);
   }
   const ab = await res.arrayBuffer();
   return Buffer.from(ab);
@@ -43440,8 +43720,8 @@ async function getFileboxConnections(client, params = {}, options) {
   if (params.fileboxId !== void 0) {
     qs.set("filebox_id", String(params.fileboxId));
   }
-  const path11 = qs.toString() === "" ? "/api/reconciliation/filebox/connections" : `/api/reconciliation/filebox/connections?${qs.toString()}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs.toString() === "" ? "/api/reconciliation/filebox/connections" : `/api/reconciliation/filebox/connections?${qs.toString()}`;
+  const out = await client.getJSON(path12, options);
   return out ?? [];
 }
 async function getFileboxConnection(client, params, options) {
@@ -43482,8 +43762,8 @@ async function deleteFileboxConnection(client, connectionId, options) {
   );
 }
 async function getFileboxSyncProgress(client, params, options) {
-  const path11 = `/api/reconciliation/filebox/connections/${params.connectionId}/sync/progress`;
-  const res = await client.do("GET", path11, void 0, options);
+  const path12 = `/api/reconciliation/filebox/connections/${params.connectionId}/sync/progress`;
+  const res = await client.do("GET", path12, void 0, options);
   const text2 = await res.text();
   if (res.status === 200 || res.status === 409) {
     if (text2 === "" || text2 === '""') {
@@ -43493,11 +43773,11 @@ async function getFileboxSyncProgress(client, params, options) {
       return JSON.parse(text2);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`GET ${path11}: decode: ${msg}`);
+      throw new Error(`GET ${path12}: decode: ${msg}`);
     }
   }
   const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-  throw new Error(`GET ${path11}: HTTP ${res.status}: ${truncated}`);
+  throw new Error(`GET ${path12}: HTTP ${res.status}: ${truncated}`);
 }
 async function getFileboxUnlinkedCount(client, params, options) {
   const qs = new URLSearchParams();
@@ -43643,15 +43923,15 @@ import { promises as fs17 } from "fs";
 var ASSIGNEE_REQUIRED = ["account_id", "type", "user_id"];
 var ASSIGNEE_OPTIONAL = ["user_name", "user_email"];
 var CLEAR_REQUIRED = ["account_id", "type"];
-async function readAssigneeCsv(path11) {
-  return parseAssigneeCsvText(await readFileArg(path11));
+async function readAssigneeCsv(path12) {
+  return parseAssigneeCsvText(await readFileArg(path12));
 }
-async function readClearAssigneeCsv(path11) {
-  return parseClearAssigneeCsvText(await readFileArg(path11));
+async function readClearAssigneeCsv(path12) {
+  return parseClearAssigneeCsvText(await readFileArg(path12));
 }
-async function readFileArg(path11) {
+async function readFileArg(path12) {
   try {
-    return await fs17.readFile(path11, "utf8");
+    return await fs17.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -44901,7 +45181,7 @@ function chunkByJsonBytes(rows, maxBytes) {
   return chunks;
 }
 function settingsActionId(settings) {
-  return createHash9("sha256").update(JSON.stringify(settings)).digest("hex").slice(0, 12);
+  return createHash10("sha256").update(JSON.stringify(settings)).digest("hex").slice(0, 12);
 }
 async function runReconciliationAccountsUpdateSettings(cfg) {
   const action = {
@@ -45279,7 +45559,7 @@ async function runReconciliationAccountsSetAssignee(cfg) {
 var ASSIGNEE_BATCH_CHUNK_SIZE = 100;
 function assigneeBatchActionId(date, rows) {
   const canonical = rows.map((r) => [r.accountId, r.type, r.userId, r.userName, r.userEmail]);
-  return createHash9("sha256").update(JSON.stringify([date, canonical])).digest("hex").slice(0, 12);
+  return createHash10("sha256").update(JSON.stringify([date, canonical])).digest("hex").slice(0, 12);
 }
 async function runReconciliationAccountsSetAssigneeBatch(cfg) {
   const action = {
@@ -45433,7 +45713,7 @@ verify the date matches the accounts' reporting period (try \`dr reconciliation
 }
 function clearBatchActionId(date, rows) {
   const canonical = rows.map((r) => [r.accountId, r.type]);
-  return createHash9("sha256").update(JSON.stringify(["clear", date, canonical])).digest("hex").slice(0, 12);
+  return createHash10("sha256").update(JSON.stringify(["clear", date, canonical])).digest("hex").slice(0, 12);
 }
 async function runReconciliationAccountsClearAssigneeBatch(cfg) {
   const action = {
@@ -46757,7 +47037,7 @@ function applyProse(data4, overlay, warn2 = () => {
 
 // src/commands/_validateReportRender.ts
 import { readFile as readFile6 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var MARKER = "<!--__DATA_BLOCK__-->";
 function renderReportHtml(data4, templateHtml) {
   if (!templateHtml.includes(MARKER)) {
@@ -46768,7 +47048,7 @@ function renderReportHtml(data4, templateHtml) {
   return templateHtml.replace(MARKER, block);
 }
 function reportTemplatePath() {
-  return join12(findSkillDir("dr-validate"), "report-template.html");
+  return join13(findSkillDir("dr-validate"), "report-template.html");
 }
 async function readReportTemplate() {
   return readFile6(reportTemplatePath(), "utf8");
@@ -47323,7 +47603,7 @@ function renderForError(v) {
 }
 
 // src/commands/mecWorkflow.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 
 // src/api/workflow.ts
 function buildQueryString(params) {
@@ -47338,13 +47618,13 @@ function buildQueryString(params) {
   }
   return parts.length === 0 ? "" : `?${parts.join("&")}`;
 }
-async function deleteWithBody(client, path11, body, options) {
+async function deleteWithBody(client, path12, body, options) {
   const encoded = JSON.stringify(body);
-  const res = await client.do("DELETE", path11, encoded, options);
+  const res = await client.do("DELETE", path12, encoded, options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`DELETE ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`DELETE ${path12}: HTTP ${res.status}: ${truncated}`);
   }
   await res.text();
 }
@@ -48084,10 +48364,10 @@ var STEP_TYPES = [
   "BudgetInput"
 ];
 var ROLES = ["WORKFLOW_V2_OWNER_ROLE", "WORKFLOW_V2_EDITOR_ROLE"];
-async function readJsonFile(path11) {
+async function readJsonFile(path12) {
   let raw;
   try {
-    raw = await fs20.readFile(path11, "utf8");
+    raw = await fs20.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -48146,16 +48426,16 @@ function asParticipantId(value, where) {
   const obj = asObject2(value, where);
   return asPositiveInt(obj["id"], `${where}.id`);
 }
-async function readTemplateCreatePayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readTemplateCreatePayload(path12) {
+  const raw = await readJsonFile(path12);
   return validateTemplatePayload(
     raw,
     /* requireAll */
     true
   );
 }
-async function readTemplateUpdatePayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readTemplateUpdatePayload(path12) {
+  const raw = await readJsonFile(path12);
   return validateTemplatePayload(
     raw,
     /* requireAll */
@@ -48254,16 +48534,16 @@ function validateTagsArray(raw) {
     };
   });
 }
-async function readStepCreatePayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readStepCreatePayload(path12) {
+  const raw = await readJsonFile(path12);
   return validateStepPayload(
     raw,
     /* requireAll */
     true
   );
 }
-async function readStepUpdatePayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readStepUpdatePayload(path12) {
+  const raw = await readJsonFile(path12);
   return validateStepPayload(
     raw,
     /* requireAll */
@@ -48333,8 +48613,8 @@ function validateStepPayload(raw, requireAll) {
   requireBool("required_task_approval");
   return out;
 }
-async function readStepReorderPayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readStepReorderPayload(path12) {
+  const raw = await readJsonFile(path12);
   const arr = asArray2(raw, "reorder");
   return arr.map((row, idx) => {
     const obj = asObject2(row, `reorder[${idx}]`);
@@ -48345,8 +48625,8 @@ async function readStepReorderPayload(path11) {
     };
   });
 }
-async function readFileTaskCreatePayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readFileTaskCreatePayload(path12) {
+  const raw = await readJsonFile(path12);
   const arr = Array.isArray(raw) ? raw : [raw];
   if (arr.length === 0) {
     throw new Error("--file task: empty array");
@@ -48377,8 +48657,8 @@ function validateFileTaskRow(raw, where) {
   }
   return out;
 }
-async function readNonFileTaskCreatePayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readNonFileTaskCreatePayload(path12) {
+  const raw = await readJsonFile(path12);
   const arr = Array.isArray(raw) ? raw : [raw];
   if (arr.length === 0) {
     throw new Error("--file task: empty array");
@@ -48415,12 +48695,12 @@ function validateNonFileTaskRow(raw, where) {
   }
   return out;
 }
-async function readNonFileTaskUpdateOnePayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readNonFileTaskUpdateOnePayload(path12) {
+  const raw = await readJsonFile(path12);
   return validateNonFileTaskRow(raw, "task");
 }
-async function readFileTaskNotifyPayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readFileTaskNotifyPayload(path12) {
+  const raw = await readJsonFile(path12);
   const obj = asObject2(raw, "notify");
   const assignees = asArray2(obj["assignees"], "notify.assignees").map((row, idx) => {
     const r = asObject2(row, `notify.assignees[${idx}]`);
@@ -48445,8 +48725,8 @@ async function readFileTaskNotifyPayload(path11) {
   }
   return out;
 }
-async function readNonFileTaskNotifyPayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readNonFileTaskNotifyPayload(path12) {
+  const raw = await readJsonFile(path12);
   const obj = asObject2(raw, "notify");
   const assignees = asArray2(obj["assignees"], "notify.assignees").map((row, idx) => {
     const r = asObject2(row, `notify.assignees[${idx}]`);
@@ -48468,8 +48748,8 @@ async function readNonFileTaskNotifyPayload(path11) {
   }
   return out;
 }
-async function readTaskApprovePayload(path11, approved) {
-  const raw = await readJsonFile(path11);
+async function readTaskApprovePayload(path12, approved) {
+  const raw = await readJsonFile(path12);
   const obj = asObject2(raw, "approve");
   const tasks = asArray2(obj["tasks"], "approve.tasks").map((row, idx) => {
     const r = asObject2(row, `approve.tasks[${idx}]`);
@@ -48517,8 +48797,8 @@ function validateRoleOrId(value, where) {
   }
   return s;
 }
-async function readMemberAddPayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readMemberAddPayload(path12) {
+  const raw = await readJsonFile(path12);
   const obj = asObject2(raw, "member");
   const emails = asArray2(obj["emails"], "member.emails").map(
     (e, idx) => asString(e, `member.emails[${idx}]`)
@@ -48529,8 +48809,8 @@ async function readMemberAddPayload(path11) {
   const role = validateRoleOrId(obj["role"], "member.role");
   return { emails, role };
 }
-async function readGroupAddPayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readGroupAddPayload(path12) {
+  const raw = await readJsonFile(path12);
   const arr = Array.isArray(raw) ? raw : [raw];
   if (arr.length === 0) {
     throw new Error("--file group: empty array");
@@ -48543,8 +48823,8 @@ async function readGroupAddPayload(path11) {
     };
   });
 }
-async function readMemberGrantBulkPayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readMemberGrantBulkPayload(path12) {
+  const raw = await readJsonFile(path12);
   const obj = asObject2(raw, "grant-bulk");
   const emails = asArray2(obj["emails"], "grant-bulk.emails").map(
     (e, idx) => asString(e, `grant-bulk.emails[${idx}]`)
@@ -48564,8 +48844,8 @@ async function readMemberGrantBulkPayload(path11) {
     role: validateRoleOrId(obj["role"], "grant-bulk.role")
   };
 }
-async function readGroupGrantBulkPayload(path11) {
-  const raw = await readJsonFile(path11);
+async function readGroupGrantBulkPayload(path12) {
+  const raw = await readJsonFile(path12);
   const obj = asObject2(raw, "grant-bulk");
   const permission_groups = asArray2(obj["permission_groups"], "grant-bulk.permission_groups").map(
     (id, idx) => asPositiveInt(id, `grant-bulk.permission_groups[${idx}]`)
@@ -48639,10 +48919,10 @@ function parseStepReorderShorthand(raw) {
 }
 
 // src/commands/_mecWorkflowFile.ts
-async function readJsonFile2(path11) {
+async function readJsonFile2(path12) {
   let raw;
   try {
-    raw = await fs21.readFile(path11, "utf8");
+    raw = await fs21.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -48686,16 +48966,16 @@ function asNonNegativeInt2(value, where) {
 }
 var MEC_WORKFLOW_TYPE = "Month End Close";
 var NON_MEC_TYPES_HINT = "Financial Reporting | Budget | Forecast | Other";
-async function readMecTemplateCreatePayload(path11) {
-  const raw = await readJsonFile2(path11);
+async function readMecTemplateCreatePayload(path12) {
+  const raw = await readJsonFile2(path12);
   return validateMecTemplatePayload(
     raw,
     /* requireAll */
     true
   );
 }
-async function readMecTemplateUpdatePayload(path11) {
-  const raw = await readJsonFile2(path11);
+async function readMecTemplateUpdatePayload(path12) {
+  const raw = await readJsonFile2(path12);
   return validateMecTemplatePayload(
     raw,
     /* requireAll */
@@ -49373,13 +49653,13 @@ async function runMecAccountsTaskStatuses(cfg) {
   }
   renderMecAccountsTasksOrStatuses(cfg.out, resp, "statuses");
 }
-function shortHash3(input) {
-  return createHash10("sha256").update(input).digest("hex").slice(0, 12);
+function shortHash4(input) {
+  return createHash11("sha256").update(input).digest("hex").slice(0, 12);
 }
 async function runMecWorkflowCreate(cfg) {
   const action = {
     resource: "mec-workflow-template",
-    id: shortHash3(JSON.stringify(cfg.payload)),
+    id: shortHash4(JSON.stringify(cfg.payload)),
     verb: "create"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -50026,7 +50306,7 @@ async function runMecTaskDelete(cfg) {
   const sortedIds = [...cfg.ids].map((r) => r.id).sort((a, b) => a - b);
   const action = {
     resource: "mec-workflow-task-batch",
-    id: `${cfg.stepId}:${shortHash3(sortedIds.join(","))}`,
+    id: `${cfg.stepId}:${shortHash4(sortedIds.join(","))}`,
     verb: "bulk-delete"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -50189,7 +50469,7 @@ async function runMecTaskSignOff(cfg) {
   const sortedIds = [...cfg.ids].sort((a, b) => a - b);
   const action = {
     resource: "mec-workflow-task",
-    id: `${cfg.stepId}:${shortHash3(sortedIds.join(","))}`,
+    id: `${cfg.stepId}:${shortHash4(sortedIds.join(","))}`,
     verb: cfg.isSignOff ? "sign-off" : "reopen"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -50388,7 +50668,7 @@ async function runMecMemberGrantBulk(cfg) {
   const hashInput = cfg.payload.emails.join(",") + "|" + cfg.payload.entities_ids.join(",") + "|" + cfg.payload.role;
   const action = {
     resource: "mec-workflow-member-grant",
-    id: shortHash3(hashInput),
+    id: shortHash4(hashInput),
     verb: "bulk"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -50544,7 +50824,7 @@ async function runMecGroupGrantBulk(cfg) {
   const hashInput = cfg.payload.permission_groups.join(",") + "|" + cfg.payload.entities_ids.join(",") + "|" + cfg.payload.role;
   const action = {
     resource: "mec-workflow-group-grant",
-    id: shortHash3(hashInput),
+    id: shortHash4(hashInput),
     verb: "bulk"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -51758,7 +52038,7 @@ function wireMec(program) {
 }
 
 // src/commands/workflow.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 function dash6(s) {
   if (s === null || s === void 0) return "-";
   if (typeof s === "number") return String(s);
@@ -52226,13 +52506,13 @@ function renderGroupList(out, rows) {
 (${rows.length} group${plural(rows.length)})
 `);
 }
-function shortHash4(input) {
-  return createHash11("sha256").update(input).digest("hex").slice(0, 12);
+function shortHash5(input) {
+  return createHash12("sha256").update(input).digest("hex").slice(0, 12);
 }
 async function runWorkflowCreate(cfg) {
   const action = {
     resource: "workflow-template",
-    id: shortHash4(JSON.stringify(cfg.payload)),
+    id: shortHash5(JSON.stringify(cfg.payload)),
     verb: "create"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -52874,7 +53154,7 @@ async function runTaskDelete(cfg) {
   const sortedIds = [...cfg.ids].map((r) => r.id).sort((a, b) => a - b);
   const action = {
     resource: "workflow-task-batch",
-    id: `${cfg.stepId}:${shortHash4(sortedIds.join(","))}`,
+    id: `${cfg.stepId}:${shortHash5(sortedIds.join(","))}`,
     verb: "bulk-delete"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -53037,7 +53317,7 @@ async function runTaskSignOff(cfg) {
   const sortedIds = [...cfg.ids].sort((a, b) => a - b);
   const action = {
     resource: "workflow-task",
-    id: `${cfg.stepId}:${shortHash4(sortedIds.join(","))}`,
+    id: `${cfg.stepId}:${shortHash5(sortedIds.join(","))}`,
     verb: cfg.isSignOff ? "sign-off" : "reopen"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -53234,7 +53514,7 @@ async function runMemberGrantBulk(cfg) {
   const hashInput = cfg.payload.emails.join(",") + "|" + cfg.payload.entities_ids.join(",") + "|" + cfg.payload.role;
   const action = {
     resource: "workflow-member-grant",
-    id: shortHash4(hashInput),
+    id: shortHash5(hashInput),
     verb: "bulk"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -53390,7 +53670,7 @@ async function runGroupGrantBulk(cfg) {
   const hashInput = cfg.payload.permission_groups.join(",") + "|" + cfg.payload.entities_ids.join(",") + "|" + cfg.payload.role;
   const action = {
     resource: "workflow-group-grant",
-    id: shortHash4(hashInput),
+    id: shortHash5(hashInput),
     verb: "bulk"
   };
   await preflightConfirmToken(action, cfg.token);
@@ -54386,7 +54666,7 @@ function wireWorkflow(root) {
 }
 
 // src/commands/cash.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { promises as fs25 } from "fs";
 
 // src/api/cash.ts
@@ -54428,8 +54708,8 @@ async function putTransactions(client, params, payload, options) {
   return out ?? { count: 0, next: null, previous: null, results: [] };
 }
 async function rescanTemplateRules(client, params, options) {
-  const path11 = `/api/templates/${params.templateId}/rules/rescan`;
-  const res = await client.do("POST", path11, void 0, options);
+  const path12 = `/api/templates/${params.templateId}/rules/rescan`;
+  const res = await client.do("POST", path12, void 0, options);
   const text2 = await res.text();
   let body = text2;
   if (body.startsWith('"') && body.endsWith('"') && body.length >= 2) {
@@ -54442,7 +54722,7 @@ async function rescanTemplateRules(client, params, options) {
     return { status: res.status, body };
   }
   const truncated = body.length > 200 ? `${body.slice(0, 200)}\u2026` : body;
-  throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncated}`);
+  throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncated}`);
 }
 async function listRules(client, params, options) {
   const qs = params.archived === true ? "?is_archive=true" : "";
@@ -54504,12 +54784,12 @@ async function reorderRules(client, params, payload, options) {
 }
 async function exportRulesCsv(client, params, options) {
   const qs = params.archived === true ? "?is_archive=true" : "";
-  const path11 = `/api/templates/${params.templateId}/rules/export_to_csv${qs}`;
-  const res = await client.do("POST", path11, void 0, options);
+  const path12 = `/api/templates/${params.templateId}/rules/export_to_csv${qs}`;
+  const res = await client.do("POST", path12, void 0, options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncated}`);
   }
   const csv = await res.text();
   const disposition = res.headers.get("content-disposition") ?? "";
@@ -54530,19 +54810,19 @@ async function upsertHiddenRules(client, params, payload, options) {
   return out ?? [];
 }
 async function deleteHiddenRules(client, params, customerTransactionIds, options) {
-  const path11 = `/api/templates/${params.templateId}/hidden_rules`;
+  const path12 = `/api/templates/${params.templateId}/hidden_rules`;
   const body = JSON.stringify(customerTransactionIds);
-  const res = await client.do("DELETE", path11, body, options);
+  const res = await client.do("DELETE", path12, body, options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`DELETE ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`DELETE ${path12}: HTTP ${res.status}: ${truncated}`);
   }
   await res.text();
 }
 async function triggerAiRules(client, options) {
-  const path11 = `/api/templates/ai-rules`;
-  const res = await client.do("POST", path11, void 0, options);
+  const path12 = `/api/templates/ai-rules`;
+  const res = await client.do("POST", path12, void 0, options);
   const text2 = await res.text();
   let body = text2;
   if (body.startsWith('"') && body.endsWith('"') && body.length >= 2) {
@@ -54555,7 +54835,7 @@ async function triggerAiRules(client, options) {
     return { status: res.status, body };
   }
   const truncated = body.length > 200 ? `${body.slice(0, 200)}\u2026` : body;
-  throw new Error(`POST ${path11}: HTTP ${res.status}: ${truncated}`);
+  throw new Error(`POST ${path12}: HTTP ${res.status}: ${truncated}`);
 }
 
 // src/commands/_cashRuleFile.ts
@@ -54575,10 +54855,10 @@ var OPERATIONS = [
   "WILDCARD"
 ];
 var STATUSES = ["active", "inactive", "archived"];
-async function readJsonFile3(path11) {
+async function readJsonFile3(path12) {
   let raw;
   try {
-    raw = await fs23.readFile(path11, "utf8");
+    raw = await fs23.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -54590,8 +54870,8 @@ async function readJsonFile3(path11) {
     throw new Error(`parse --file: ${m}`);
   }
 }
-async function readCreatePayload(path11) {
-  const raw = await readJsonFile3(path11);
+async function readCreatePayload(path12) {
+  const raw = await readJsonFile3(path12);
   if (Array.isArray(raw)) {
     const rules = [];
     raw.forEach((entry, idx) => {
@@ -54604,19 +54884,19 @@ async function readCreatePayload(path11) {
   }
   return { kind: "single", rule: validateCreate(raw, "rule") };
 }
-async function readUpdatePayload(path11) {
-  const raw = await readJsonFile3(path11);
+async function readUpdatePayload(path12) {
+  const raw = await readJsonFile3(path12);
   if (Array.isArray(raw)) {
     throw new Error("--file: update payload must be an object, not an array");
   }
   return validateCreate(raw, "rule");
 }
-async function readReorderPayload(path11) {
-  const raw = await readJsonFile3(path11);
+async function readReorderPayload(path12) {
+  const raw = await readJsonFile3(path12);
   return validateReorder(raw, "payload");
 }
-async function readHiddenRulesPayload(path11) {
-  const raw = await readJsonFile3(path11);
+async function readHiddenRulesPayload(path12) {
+  const raw = await readJsonFile3(path12);
   if (!Array.isArray(raw)) {
     throw new Error("--file: hidden-rules payload must be a JSON array");
   }
@@ -54844,10 +55124,10 @@ function validateReorder(raw, ctx) {
 // src/commands/_cashRuleCsv.ts
 import { promises as fs24 } from "fs";
 var EXPECTED_HEADER5 = ["Detailed Rule", "Parameters", "Category"];
-async function readCsvImportPayload(path11) {
+async function readCsvImportPayload(path12) {
   let raw;
   try {
-    raw = await fs24.readFile(path11, "utf8");
+    raw = await fs24.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --file: ${m}`);
@@ -55477,7 +55757,7 @@ async function runCashRulesDeleteAll(cfg) {
     return;
   }
   const ids = targets.map((r) => r.id).sort((a, b) => a - b);
-  const sha = createHash12("sha256").update(ids.join(",")).digest("hex").slice(0, 12);
+  const sha = createHash13("sha256").update(ids.join(",")).digest("hex").slice(0, 12);
   const action = {
     resource: "cash-rules-batch",
     id: `${templateId}:${sha}`,
@@ -56621,12 +56901,12 @@ async function renameGroup(client, body, options) {
   return client.putJSON("/bo/pre_kickoff/qbo_manage_companies/v2", body, options);
 }
 async function deleteEntity(client, body, options) {
-  const path11 = "/bo/pre_kickoff/qbo_manage_companies/v2";
-  const res = await client.do("DELETE", path11, JSON.stringify(body), options);
+  const path12 = "/bo/pre_kickoff/qbo_manage_companies/v2";
+  const res = await client.do("DELETE", path12, JSON.stringify(body), options);
   if (res.status < 200 || res.status >= 300) {
     const text2 = await res.text();
     const truncated = text2.length > 200 ? `${text2.slice(0, 200)}\u2026` : text2;
-    throw new Error(`DELETE ${path11}: HTTP ${res.status}: ${truncated}`);
+    throw new Error(`DELETE ${path12}: HTTP ${res.status}: ${truncated}`);
   }
 }
 async function markAsManuallyCompleted(client, documentId, options) {
@@ -60434,9 +60714,9 @@ function registerKbCommand(root) {
 // src/mcp/claudeConfig.ts
 import { promises as fs28 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname8, join as join13 } from "path";
+import { dirname as dirname8, join as join14 } from "path";
 function configPath(opts) {
-  return join13(opts.home ?? homedir4(), ".claude.json");
+  return join14(opts.home ?? homedir4(), ".claude.json");
 }
 async function readClaudeConfig(opts = {}) {
   const p = configPath(opts);
@@ -60608,8 +60888,8 @@ function buildContractListQuery(params) {
 }
 async function listContracts(client, params = {}, options) {
   const qs = buildContractListQuery(params);
-  const path11 = qs === "" ? `${BASE2}/contracts/` : `${BASE2}/contracts/?${qs}`;
-  const out = await client.getJSON(path11, options);
+  const path12 = qs === "" ? `${BASE2}/contracts/` : `${BASE2}/contracts/?${qs}`;
+  const out = await client.getJSON(path12, options);
   if (out === null) {
     return { items: [], total: 0, page: null, size: null, pages: null };
   }
@@ -61272,9 +61552,9 @@ function buildVendorListQuery(params) {
   if (params.size !== void 0) qs.set("size", String(params.size));
   return qs.toString();
 }
-function withQuery(path11, params) {
+function withQuery(path12, params) {
   const qs = buildVendorListQuery(params);
-  return qs === "" ? path11 : `${path11}?${qs}`;
+  return qs === "" ? path12 : `${path12}?${qs}`;
 }
 function emptyPage() {
   return { items: [], total: 0, page: null, size: null, pages: null };
@@ -62387,10 +62667,10 @@ async function preflightFile(filePath) {
     mime
   };
 }
-async function readDraft(path11) {
+async function readDraft(path12) {
   let raw;
   try {
-    raw = await fsPromises3.readFile(path11, "utf8");
+    raw = await fsPromises3.readFile(path12, "utf8");
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     throw new Error(`read --from: ${m}`);
@@ -62974,13 +63254,13 @@ batch ${i + 1}/${batches.length} failed: ${msg}
     }
   });
 }
-async function appendCreatedSidecar(path11, contracts) {
+async function appendCreatedSidecar(path12, contracts) {
   if (contracts.length === 0) return;
   const lines = contracts.map((c) => {
     const vendor = c.vendor !== void 0 && c.vendor !== null ? c.vendor.name : "";
     return `${c.id}	${vendor}`;
   }).join("\n");
-  await fsPromises3.appendFile(path11, lines + "\n", "utf8");
+  await fsPromises3.appendFile(path12, lines + "\n", "utf8");
 }
 async function runContractUpdate(cfg) {
   let raw;
@@ -64465,7 +64745,7 @@ function registerMultiProductCommand(root) {
 
 // src/commands/desk.ts
 import { promises as fs31 } from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { Option as Option3 } from "commander";
 
 // src/api/desk.ts
@@ -64500,14 +64780,14 @@ async function getSmtpConnection(client, teamId, options) {
   }
 }
 async function testSmtpConnection(client, teamId, options) {
-  const path11 = `${TEAMS}/${teamId}/smtp-connection/test`;
-  const out = await client.postJSON(path11, {}, options);
-  return required(out, `POST ${path11}`);
+  const path12 = `${TEAMS}/${teamId}/smtp-connection/test`;
+  const out = await client.postJSON(path12, {}, options);
+  return required(out, `POST ${path12}`);
 }
 async function setTeamSupportEmail(client, teamId, emailAddress, options) {
-  const path11 = `/bo/teams/${teamId}/`;
-  const out = await client.patchJSON(path11, { support_email: emailAddress }, options);
-  return required(out, `PATCH ${path11}`);
+  const path12 = `/bo/teams/${teamId}/`;
+  const out = await client.patchJSON(path12, { support_email: emailAddress }, options);
+  return required(out, `PATCH ${path12}`);
 }
 async function registerSendgridDomain(client, domain, options) {
   const out = await client.postJSON(
@@ -64518,38 +64798,38 @@ async function registerSendgridDomain(client, domain, options) {
   return required(out, `POST ${TEAMS}/onboarding/sendgrid`);
 }
 async function getSendgridDomainStatus(client, domain, options) {
-  const path11 = `${TEAMS}/onboarding/sendgrid${querySuffix(domain)}`;
-  const out = await client.getJSON(path11, options);
-  return required(out, `GET ${path11}`);
+  const path12 = `${TEAMS}/onboarding/sendgrid${querySuffix(domain)}`;
+  const out = await client.getJSON(path12, options);
+  return required(out, `GET ${path12}`);
 }
 async function verifySendgridDomain(client, domain, options) {
-  const path11 = `${TEAMS}/onboarding/sendgrid/verify${querySuffix(domain)}`;
-  const out = await client.postJSON(path11, {}, options);
-  return required(out, `POST ${path11}`);
+  const path12 = `${TEAMS}/onboarding/sendgrid/verify${querySuffix(domain)}`;
+  const out = await client.postJSON(path12, {}, options);
+  return required(out, `POST ${path12}`);
 }
 async function createTicket(client, body, options) {
   const out = await client.postJSON(TICKETS, body, options);
   return required(out, `POST ${TICKETS}`);
 }
 async function createTicketMessage(client, ticketId, body, options) {
-  const path11 = `${TICKETS}${encodeURIComponent(ticketId)}/messages/`;
-  const out = await client.postJSON(path11, body, options);
-  return required(out, `POST ${path11}`);
+  const path12 = `${TICKETS}${encodeURIComponent(ticketId)}/messages/`;
+  const out = await client.postJSON(path12, body, options);
+  return required(out, `POST ${path12}`);
 }
 async function uploadTicketAttachment(client, ticketId, file, filename, messageId, options) {
-  const path11 = `${TICKETS}${encodeURIComponent(ticketId)}/attachments/upload`;
+  const path12 = `${TICKETS}${encodeURIComponent(ticketId)}/attachments/upload`;
   const fields = messageId === void 0 ? {} : { message_id: messageId };
-  const out = await client.postMultipart(path11, fields, file, {
+  const out = await client.postMultipart(path12, fields, file, {
     fileFieldName: "file",
     filename,
     ...options
   });
-  return required(out, `POST ${path11}`);
+  return required(out, `POST ${path12}`);
 }
 async function orgClone(client, payload, options) {
-  const path11 = "/api/desk/v1/admin/org-clone";
-  const out = await client.postJSON(path11, payload, options);
-  return required(out, `POST ${path11}`);
+  const path12 = "/api/desk/v1/admin/org-clone";
+  const out = await client.postJSON(path12, payload, options);
+  return required(out, `POST ${path12}`);
 }
 function querySuffix(domain) {
   if (domain === void 0 || domain === "") return "";
@@ -65124,8 +65404,8 @@ async function planAttachments(paths, stat2 = async (p) => {
   for (const raw of paths) {
     const filePath = raw.trim();
     if (filePath === "") throw new Error("--attach needs a path.");
-    const filename = path9.basename(filePath);
-    const ext = path9.extname(filename).toLowerCase();
+    const filename = path10.basename(filePath);
+    const ext = path10.extname(filename).toLowerCase();
     const contentType = ATTACHMENT_CONTENT_TYPES[ext];
     if (contentType === void 0) {
       throw new Error(
@@ -66446,12 +66726,12 @@ function registerAppSpaceCommand(root) {
 // src/auth/versionCheck.ts
 import { promises as fs33 } from "fs";
 import * as os4 from "os";
-import * as path10 from "path";
+import * as path11 from "path";
 var LATEST_JSON_URL = "https://drcli.datarails.com/cli/latest.json";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 4e3;
 function cachePath() {
-  return path10.join(os4.homedir(), ".dr", "version-check.json");
+  return path11.join(os4.homedir(), ".dr", "version-check.json");
 }
 function compareSemver(a, b) {
   const norm = (s) => {
@@ -66485,7 +66765,7 @@ async function readCache() {
 }
 async function writeCache(entry) {
   const target = cachePath();
-  const dir = path10.dirname(target);
+  const dir = path11.dirname(target);
   await fs33.mkdir(dir, { recursive: true });
   const tmp = `${target}.tmp.${process.pid}`;
   await fs33.writeFile(tmp, JSON.stringify(entry), { mode: 384 });
@@ -66901,7 +67181,7 @@ function commandPath(actionCommand) {
 
 // src/telemetry/config.ts
 import { homedir as homedir6 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { readFile as readFile7 } from "fs/promises";
 var TELEMETRY_ENV = "DR_CLI_TELEMETRY";
 var DISABLED_VALUES = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
@@ -66935,12 +67215,12 @@ function parseCollectorConfig(raw) {
   return { endpoint, headerName, headerValue };
 }
 function remoteSettingsPath() {
-  return join15(homedir6(), ".claude", "remote-settings.json");
+  return join16(homedir6(), ".claude", "remote-settings.json");
 }
-async function readCollectorConfig(path11 = remoteSettingsPath()) {
+async function readCollectorConfig(path12 = remoteSettingsPath()) {
   let raw;
   try {
-    raw = await readFile7(path11, "utf8");
+    raw = await readFile7(path12, "utf8");
   } catch {
     return null;
   }