@madewithremy/admin 0.1.7 → 0.1.9

package/dist/prod.js

@@ -36,10 +36,10 @@ function fatal(message) {
   throw new CliError(message);
 }
 var AdminApiError = class extends Error {
-  constructor(method, path5, status2, body) {
-    super(`API ${method} ${path5} returned ${status2}: ${JSON.stringify(body)}`);
+  constructor(method, path7, status2, body) {
+    super(`API ${method} ${path7} returned ${status2}: ${JSON.stringify(body)}`);
     this.method = method;
-    this.path = path5;
+    this.path = path7;
     this.status = status2;
     this.body = body;
     this.name = "AdminApiError";
@@ -935,7 +935,7 @@ async function waitForCommit(ctx, params) {
   const { commitSha, onProgress } = params;
   const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const shortSha = commitSha.slice(0, 8);
-  const start = Date.now();
+  const start2 = Date.now();
   let release;
   while (true) {
     const r = await byCommit(ctx, commitSha);
@@ -948,7 +948,7 @@ async function waitForCommit(ctx, params) {
         `Failed to resolve release for ${shortSha}: HTTP ${r.status} ${JSON.stringify(r.body)}`
       );
     }
-    if (Date.now() - start > RESOLVE_GRACE_MS) {
+    if (Date.now() - start2 > RESOLVE_GRACE_MS) {
       return {
         outcome: "not_found",
         error: `No release created for commit ${commitSha} within ${RESOLVE_GRACE_MS / 1e3}s \u2014 either the push hasn't registered yet or this SHA never produced a build`
@@ -976,7 +976,7 @@ async function waitForCommit(ctx, params) {
         summary: summarizeRelease(release)
       };
     }
-    if (Date.now() - start > timeoutMs) {
+    if (Date.now() - start2 > timeoutMs) {
       return {
         outcome: "timeout",
         release,
@@ -985,7 +985,7 @@ async function waitForCommit(ctx, params) {
       };
     }
     onProgress?.(
-      `${release.status}\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
+      `${release.status}\u2026 (${Math.round((Date.now() - start2) / 1e3)}s)`
     );
     await sleep(POLL_MS);
     const r = await byCommit(ctx, commitSha);
@@ -1247,14 +1247,14 @@ async function diagnosticsGet(ctx, a) {
   const releaseId = await resolveReleaseId(ctx, a);
   if (a.bool("wait")) {
     const timeout = (a.num("timeout") ?? 120) * 1e3;
-    const start = Date.now();
+    const start2 = Date.now();
     while (true) {
       const release2 = await getRelease(ctx, releaseId);
       if (release2.diagnostics) {
         out(release2.diagnostics);
         return;
       }
-      if (Date.now() - start > timeout) {
+      if (Date.now() - start2 > timeout) {
         out(DIAGNOSTICS_PENDING);
         return;
       }
@@ -2869,11 +2869,55 @@ Notes:
   - Public image URLs accept transform params, e.g. ?w=400&fit=cover.`;
 
 // src/commands/dataSources.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/ops/dataSources.ts
 import { createHash as createHash2 } from "crypto";
+
+// src/poll.ts
+async function pollUntil(read, isSettled, options) {
+  const start2 = Date.now();
+  let transientSince = null;
+  while (true) {
+    let value;
+    try {
+      value = await read();
+      transientSince = null;
+    } catch (err) {
+      if (!isTransientError(err)) {
+        throw err;
+      }
+      transientSince ??= Date.now();
+      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
+        throw err;
+      }
+      options.onProgress?.(
+        `retrying after a gateway error\u2026 (${elapsedSeconds(start2)}s)`
+      );
+      await sleep(options.pollMs);
+      continue;
+    }
+    if (isSettled(value)) {
+      return { settled: true, value };
+    }
+    if (Date.now() - start2 > options.timeoutMs) {
+      return { settled: false, value };
+    }
+    if (options.describe) {
+      options.onProgress?.(options.describe(value, start2));
+    }
+    await sleep(options.pollMs);
+  }
+}
+function elapsedSeconds(start2) {
+  return Math.round((Date.now() - start2) / 1e3);
+}
+function timedOut(timeoutMs, still) {
+  return `Timed out after ${Math.round(timeoutMs / 1e3)}s ${still}`;
+}
+
+// src/ops/dataSources.ts
 var DEFAULT_WAIT_TIMEOUT_MS = 15 * 60 * 1e3;
 var POLL_MS2 = 3e3;
 function base(appId) {
@@ -2903,7 +2947,12 @@ async function addDocument(ctx, params) {
   );
   if (token.alreadyCurrent) {
     onProgress?.(`${filename}: unchanged, skipped`);
-    return { filename, skipped: true, document: token.document };
+    return {
+      filename,
+      skipped: true,
+      document: token.document,
+      documents: token.documents ?? [token.document]
+    };
   }
   onProgress?.(
     `${filename}: uploading ${(content.length / 1024 / 1024).toFixed(1)}MB\u2026`
@@ -2926,7 +2975,9 @@ async function addDocument(ctx, params) {
     filename,
     skipped: false,
     queued: confirmed.queued,
-    document: confirmed.document
+    document: confirmed.document,
+    documents: confirmed.documents ?? (confirmed.document ? [confirmed.document] : []),
+    outcome: confirmed.outcome
   };
 }
 async function waitForIngest(ctx, params) {
@@ -2936,50 +2987,64 @@ async function waitForIngest(ctx, params) {
     return { status: "up-to-date", documents: [] };
   }
   const wanted = new Set(documentIds);
-  const start = Date.now();
-  let transientSince = null;
-  for (; ; ) {
-    let docs;
-    try {
-      docs = await allDocuments(ctx, { slug, ids: documentIds });
-      transientSince = null;
-    } catch (err) {
-      if (!isTransientError(err)) {
-        throw err;
-      }
-      transientSince ??= Date.now();
-      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
-        throw err;
-      }
-      onProgress?.(
-        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
-      );
-      await sleep(POLL_MS2);
-      continue;
-    }
-    const tracked = (docs ?? []).filter((d) => wanted.has(d.id));
-    const pending = tracked.filter((d) => d.status === "processing");
-    const failed = tracked.filter((d) => d.status === "error");
-    if (pending.length === 0) {
-      return {
-        status: failed.length ? "error" : "done",
-        documents: tracked.map(summarize)
-      };
+  const pendingOf = (docs) => docs.filter((d) => d.status === "processing");
+  const outcome = await pollUntil(
+    async () => {
+      const docs = await allDocuments(ctx, { slug, ids: documentIds });
+      return (docs ?? []).filter((d) => wanted.has(d.id));
+    },
+    (tracked2) => pendingOf(tracked2).length === 0,
+    {
+      timeoutMs,
+      pollMs: POLL_MS2,
+      describe: (tracked2, start2) => `ingesting\u2026 ${tracked2.length - pendingOf(tracked2).length}/${tracked2.length} done (${elapsedSeconds(start2)}s)`,
+      onProgress
     }
-    if (Date.now() - start > timeoutMs) {
-      return {
-        status: "timeout",
-        documents: tracked.map(summarize),
-        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s with ${pending.length} document(s) still processing`
-      };
+  );
+  const tracked = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      documents: tracked.map(summarize),
+      error: timedOut(
+        timeoutMs,
+        `with ${pendingOf(tracked).length} document(s) still processing`
+      )
+    };
+  }
+  return {
+    status: tracked.some((d) => d.status === "error") ? "error" : "done",
+    documents: tracked.map(summarize)
+  };
+}
+async function waitForCandidate(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const pendingOf = (docs2) => docs2.filter((d) => d.status === "processing");
+  const outcome = await pollUntil(
+    () => allDocuments(ctx, { slug: params.slug, candidate: true }),
+    (docs2) => pendingOf(docs2).length === 0,
+    {
+      timeoutMs,
+      pollMs: POLL_MS2,
+      describe: (docs2, start2) => `rebuilding\u2026 ${docs2.length - pendingOf(docs2).length}/${docs2.length} done (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
     }
-    onProgress?.(
-      `ingesting\u2026 ${tracked.length - pending.length}/${tracked.length} done (${Math.round(
-        (Date.now() - start) / 1e3
-      )}s)`
-    );
-    await sleep(POLL_MS2);
+  );
+  const docs = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      documents: docs.map(summarize),
+      error: timedOut(
+        timeoutMs,
+        `with ${pendingOf(docs).length} document(s) still building`
+      )
+    };
   }
+  return {
+    status: docs.some((d) => d.status === "error") ? "error" : "ready",
+    documents: docs.map(summarize)
+  };
 }
 var DOCUMENTS_IDS_MAX = 200;
 function documents(ctx, params) {
@@ -3087,110 +3152,1801 @@ function move(ctx, params) {
 }
 async function waitForMove(ctx, params) {
   const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
-  const start = Date.now();
-  let transientSince = null;
-  for (; ; ) {
-    let source;
-    try {
+  const outcome = await pollUntil(
+    async () => {
       const { dataSources } = await list8(ctx);
-      source = dataSources.find((s) => s.slug === params.slug);
-      transientSince = null;
-    } catch (err) {
-      if (!isTransientError(err)) {
-        throw err;
-      }
-      transientSince ??= Date.now();
-      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
-        throw err;
+      const source2 = dataSources.find((s) => s.slug === params.slug);
+      if (!source2) {
+        throw new Error(`Data source "${params.slug}" not found.`);
       }
-      params.onProgress?.(
-        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
-      );
-      await sleep(POLL_MS2);
-      continue;
+      return source2;
+    },
+    (source2) => !source2.migration || source2.migration.error !== null,
+    {
+      timeoutMs,
+      pollMs: POLL_MS2,
+      describe: (source2, start2) => `moving\u2026 ${source2.migration.copied}/${source2.migration.total} documents (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
     }
-    if (!source) {
-      throw new Error(`Data source "${params.slug}" not found.`);
+  );
+  const source = outcome.value;
+  const migration = source.migration;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      source,
+      error: timedOut(
+        timeoutMs,
+        `with ${migration.copied}/${migration.total} documents copied`
+      )
+    };
+  }
+  if (migration?.error) {
+    return { status: "failed", source, error: migration.error };
+  }
+  return { status: "done", source };
+}
+function revectorize(ctx, params) {
+  const { slug, ingest } = params;
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/revectorize`,
+    {
+      slug,
+      ...ingest ? { ingest } : {}
     }
-    const migration = source.migration;
-    if (!migration) {
-      return { status: "done", source };
+  );
+}
+function promote(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/promote`,
+    {
+      slug: params.slug,
+      ...params.force ? { force: true } : {}
     }
-    if (migration.error) {
-      return { status: "failed", source, error: migration.error };
+  );
+}
+function drop(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/versions/drop`,
+    {
+      slug: params.slug,
+      ...params.version !== void 0 ? { version: params.version } : {}
     }
-    if (Date.now() - start > timeoutMs) {
-      return {
-        status: "timeout",
-        source,
-        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s with ${migration.copied}/${migration.total} documents copied`
-      };
+  );
+}
+function rm(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/documents/delete`,
+    {
+      slug: params.slug,
+      documentId: params.documentId
+    }
+  );
+}
+function rmWhere(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/documents/delete-many`,
+    { slug: params.slug, filter: params.filter }
+  );
+}
+async function rmWhereAll(ctx, params) {
+  let deleted = 0;
+  while (true) {
+    const page = await rmWhere(ctx, params);
+    deleted += page.deleted;
+    if (page.remaining === 0 || page.deleted === 0) {
+      return { deleted };
     }
     params.onProgress?.(
-      `moving\u2026 ${migration.copied}/${migration.total} documents (${Math.round(
-        (Date.now() - start) / 1e3
-      )}s)`
+      `removed ${deleted.toLocaleString()} so far, ${page.remaining.toLocaleString()} remaining\u2026`
+    );
+  }
+}
+function deleteSource(ctx, slug) {
+  return call(
+    ctx,
+    "POST",
+    `${base(ctx.appId)}/delete`,
+    { slug }
+  );
+}
+
+// src/ops/dataSourceJobs.ts
+var DEFAULT_WAIT_TIMEOUT_MS2 = 60 * 60 * 1e3;
+var POLL_MS3 = 5e3;
+function base2(appId) {
+  return `/_internal/v2/apps/${appId}/datasources/jobs`;
+}
+function start(ctx, params) {
+  const { slug, source, approve: approve2, budgetDollars, concurrency, limit } = params;
+  return call(ctx, "POST", base2(ctx.appId), {
+    slug,
+    source,
+    ...approve2 ? { approve: true } : {},
+    ...budgetDollars !== void 0 ? { budgetDollars } : {},
+    ...concurrency !== void 0 ? { concurrency } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+}
+async function uploadManifest(ctx, params) {
+  const token = await call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/manifest-token`,
+    { slug: params.slug }
+  );
+  await uploadDirect(token.upload, params.content, "manifest.jsonl");
+  return { key: token.key };
+}
+function list9(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base2(ctx.appId)}${qs({ slug: params?.slug })}`
+  );
+}
+function get7(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}`
+  );
+}
+function approve(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/approve`
+  );
+}
+function pause(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/pause`
+  );
+}
+function resume(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/resume`
+  );
+}
+function cancel(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/cancel`
+  );
+}
+function waitForPlan(ctx, params) {
+  return settle(ctx, params, (job) => job.state !== "planning");
+}
+function waitForJob(ctx, params) {
+  return settle(
+    ctx,
+    params,
+    (job) => !["planning", "planned", "running"].includes(job.state) || job.state === "planned" && (job.error !== null || !job.autoApprove)
+  );
+}
+async function settle(ctx, params, isSettled) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS2;
+  const outcome = await pollUntil(
+    async () => (await get7(ctx, { id: params.id })).job,
+    isSettled,
+    {
+      timeoutMs,
+      pollMs: POLL_MS3,
+      describe: describeProgress,
+      onProgress: params.onProgress
+    }
+  );
+  const job = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      job,
+      error: timedOut(timeoutMs, `; job is still ${job.state}`)
+    };
+  }
+  if (job.state === "failed" || job.state === "cancelled") {
+    return {
+      status: "failed",
+      job,
+      error: job.error ?? `The job was ${job.state}.`
+    };
+  }
+  if (job.state === "paused") {
+    return {
+      status: "failed",
+      job,
+      error: job.error ?? `The job paused (${job.pauseReason ?? "user"}). Resume it to continue.`
+    };
+  }
+  if (job.state === "planned" && (job.error !== null || job.autoApprove)) {
+    return {
+      status: "planned",
+      job,
+      error: job.error ?? "The plan is ready but the job did not start. Approve it once the cause is fixed."
+    };
+  }
+  return { status: "done", job };
+}
+function describeProgress(job, start2) {
+  const elapsed = `(${elapsedSeconds(start2)}s)`;
+  if (job.state === "planning") {
+    return job.enumerationDone ? `planning\u2026 reading a sample of ${job.counts.objectsSeen.toLocaleString()} objects ${elapsed}` : `planning\u2026 ${job.counts.objectsSeen.toLocaleString()} objects counted ${elapsed}`;
+  }
+  const total = job.plan?.projected.documents ?? job.counts.objectsSeen;
+  const processed = job.counts.documentsDone + job.counts.documentsSkipped + job.counts.documentsFailed;
+  const spend = `$${job.estimatedDollars.toFixed(2)}${job.budgetDollars !== null ? ` of $${job.budgetDollars.toFixed(2)}` : ""}`;
+  return `${job.state}\u2026 ${processed.toLocaleString()}/${total.toLocaleString()} documents \xB7 ${spend} ${elapsed}`;
+}
+
+// src/commands/_shared/dataSources.ts
+var DEFAULT_SOURCE = "default";
+var sourceOf = (a) => a.str("source") || DEFAULT_SOURCE;
+var timeoutOf = (a) => {
+  const seconds = a.str("timeout");
+  return seconds ? { timeoutMs: Number(seconds) * 1e3 } : {};
+};
+function failOnWait(result) {
+  if (result.status === "timeout") {
+    throw new CliError(result.error ?? "Timed out.", EXIT.timeout);
+  }
+  if (result.status === "failed" || result.status === "error") {
+    throw new CliError(result.error ?? "Failed.", EXIT.buildFailed);
+  }
+  if (result.status === "planned") {
+    throw new CliError(
+      `${result.error ?? "The plan is ready but the job did not start."} Fix the cause, then \`datasources jobs approve <id>\`.`,
+      EXIT.buildFailed
     );
-    await sleep(POLL_MS2);
   }
 }
-function revectorize(ctx, params) {
-  const { slug, ingest } = params;
+async function waitAndReport(ctx, a, id, mode, summary2) {
+  const wait = mode === "plan" ? waitForPlan : waitForJob;
+  const result = await wait(ctx, { id, ...timeoutOf(a), onProgress: progress });
+  out({ ...summary2, ...result });
+  failOnWait(result);
+}
+
+// src/ops/dataSourceConnectors.ts
+function base3(appId) {
+  return `/_internal/v2/apps/${appId}/datasources`;
+}
+function connect(ctx, params) {
+  const {
+    slug,
+    bucket,
+    region,
+    prefix,
+    endpoint,
+    accessKeyIdSecret,
+    secretAccessKeySecret,
+    deletions,
+    budgetDollarsPerSync
+  } = params;
+  return call(
+    ctx,
+    "POST",
+    `${base3(ctx.appId)}/connector`,
+    {
+      slug,
+      bucket,
+      region,
+      ...prefix !== void 0 ? { prefix } : {},
+      ...endpoint !== void 0 ? { endpoint } : {},
+      accessKeyIdSecret,
+      secretAccessKeySecret,
+      ...deletions !== void 0 ? { deletions } : {},
+      ...budgetDollarsPerSync !== void 0 ? { budgetDollarsPerSync } : {}
+    }
+  );
+}
+function get8(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base3(ctx.appId)}/connector${qs({ slug: params.slug })}`
+  );
+}
+function disconnect(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base3(ctx.appId)}/connector/remove`,
+    { slug: params.slug }
+  );
+}
+function sync(ctx, params) {
+  return call(ctx, "POST", `${base3(ctx.appId)}/sync`, {
+    slug: params.slug,
+    ...params.budgetDollars !== void 0 ? { budgetDollars: params.budgetDollars } : {}
+  });
+}
+
+// src/commands/dataSourceConnectors.ts
+var dataSourceConnectorsSpecs = {
+  "datasources connect": {
+    usage: "Usage: remy-admin datasources connect --source <slug> --bucket <name> --region <aws-region> [--prefix <p>] [--endpoint <url>] --access-key-secret <NAME> --secret-key-secret <NAME> [--deletions mirror|keep] [--budget-per-sync <dollars>]",
+    flags: {
+      source: { type: "string" },
+      bucket: { type: "string" },
+      region: { type: "string" },
+      prefix: { type: "string" },
+      endpoint: { type: "string" },
+      "access-key-secret": { type: "string" },
+      "secret-key-secret": { type: "string" },
+      deletions: { type: "string" },
+      "budget-per-sync": { type: "number", min: 0.01 }
+    }
+  },
+  "datasources connector": {
+    usage: "Usage: remy-admin datasources connector [--source <slug>]",
+    flags: { source: { type: "string" } }
+  },
+  "datasources disconnect": {
+    usage: "Usage: remy-admin datasources disconnect --source <slug>",
+    flags: { source: { type: "string" } }
+  },
+  "datasources sync": {
+    usage: "Usage: remy-admin datasources sync [--source <slug>] [--budget <dollars>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      budget: { type: "number", min: 0.01 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  }
+};
+async function connect2(ctx, a) {
+  const slug = a.str("source");
+  if (!slug) {
+    fatal("--source is required \u2014 a connector is bound to one named source.");
+  }
+  const bucket = a.str("bucket");
+  const region = a.str("region");
+  const accessKeyIdSecret = a.str("access-key-secret");
+  const secretAccessKeySecret = a.str("secret-key-secret");
+  for (const [flag, value] of [
+    ["bucket", bucket],
+    ["region", region],
+    ["access-key-secret", accessKeyIdSecret],
+    ["secret-key-secret", secretAccessKeySecret]
+  ]) {
+    if (!value) {
+      fatal(`--${flag} is required.`);
+    }
+  }
+  const deletions = a.str("deletions");
+  if (deletions && deletions !== "mirror" && deletions !== "keep") {
+    fatal(`--deletions must be "mirror" or "keep" (got "${deletions}").`);
+  }
+  const prefix = a.str("prefix");
+  const endpoint = a.str("endpoint");
+  const budget = a.num("budget-per-sync");
+  const { connector } = await connect(ctx, {
+    slug,
+    bucket,
+    region,
+    ...prefix !== void 0 ? { prefix } : {},
+    ...endpoint !== void 0 ? { endpoint } : {},
+    accessKeyIdSecret,
+    secretAccessKeySecret,
+    ...deletions ? { deletions } : {},
+    ...budget !== void 0 ? { budgetDollarsPerSync: budget } : {}
+  });
+  out({
+    dataSource: slug,
+    connector,
+    note: "Connected. Run `datasources sync --source " + slug + " --wait` to load the bucket; the first sync plans first and stops for `datasources jobs approve <id>` when the plan is over the per-sync budget."
+  });
+}
+async function show(ctx, a) {
+  const slug = sourceOf(a);
+  out({ dataSource: slug, ...await get8(ctx, { slug }) });
+}
+async function disconnect2(ctx, a) {
+  const slug = a.str("source");
+  if (!slug) {
+    fatal(
+      "--source is required \u2014 disconnecting never falls back to the default source."
+    );
+  }
+  const result = await disconnect(ctx, { slug });
+  out({
+    dataSource: slug,
+    ...result,
+    note: "The documents stay. Connect again to follow a bucket; unchanged files are recognised by content and cost nothing to re-sync."
+  });
+}
+async function sync2(ctx, a) {
+  const slug = sourceOf(a);
+  const budget = a.num("budget");
+  const { job } = await sync(ctx, {
+    slug,
+    ...budget !== void 0 ? { budgetDollars: budget } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: slug,
+      job,
+      note: "Syncing. Poll `datasources jobs status <id>`, or re-run with --wait. A plan over the per-sync budget waits in `planned` for `datasources jobs approve <id>`."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, "job", {
+    dataSource: slug,
+    action: "sync"
+  });
+}
+var dataSourceConnectorsHandlers = {
+  "datasources connect": connect2,
+  "datasources connector": show,
+  "datasources disconnect": disconnect2,
+  "datasources sync": sync2
+};
+var dataSourceConnectorsHelp = `
+Following an S3 bucket (connectors):
+  remy-admin datasources connect --source <slug> --bucket <name> --region <aws-region> [--prefix <p>] --access-key-secret <NAME> --secret-key-secret <NAME> [--deletions mirror|keep] [--budget-per-sync <dollars>]
+  remy-admin datasources connector [--source <slug>]
+  remy-admin datasources sync [--source <slug>] [--budget <dollars>] [--wait] [--timeout <sec>]
+  remy-admin datasources disconnect --source <slug>
+
+  A connector makes a bucket the customer owns the origin of a source. The
+  credentials are the NAMES of two app secrets \u2014 set them first with
+  \`remy-admin secrets set ARCHIVE_S3_KEY --prod <value>\` (or in the dashboard);
+  never put a key on a command line or in code. connect checks that both
+  secrets exist and that the keys can list the prefix before it records
+  anything, and refuses otherwise with the S3 error.
+
+  sync lists the bucket, compares every object's ETag with what was ingested
+  before, and runs a job (see above) over what is new or changed: the same
+  plan, the same gates, auto-approved under the connector's per-sync budget.
+  A plan over the budget \u2014 the first backfill of a big bucket \u2014 waits in
+  \`planned\` for \`jobs approve <id>\`; the nightly deltas run unattended.
+  A sync over an unchanged bucket costs nothing. Keys that disappeared from
+  the bucket are removed from the source at the end of a full sync under the
+  default \`--deletions mirror\`; \`--deletions keep\` leaves them. A changed
+  object replaces its document; the old one is kept as lineage.
+
+  Scheduling is the app's: a nightly sync is an ordinary cron interface job
+  whose method calls \`Source.sync()\` from the SDK. There is no platform
+  schedule to configure.
+
+  On a source without a mapper, objects whose extension no extractor reads
+  are skipped, not failed. Re-running connect with the same bucket, region,
+  prefix and endpoint updates credentials and policy in place; pointing a
+  source at a different bucket needs a disconnect first. disconnect keeps
+  every document \u2014 only the link and its object index go.
+`;
+
+// src/commands/dataSourceEvals.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/ops/dataSourceEvals.ts
+var DEFAULT_WAIT_TIMEOUT_MS3 = 30 * 60 * 1e3;
+var POLL_MS4 = 4e3;
+function base4(appId) {
+  return `/_internal/v2/apps/${appId}/datasources`;
+}
+function hydrate(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/hydrate`,
+    { slug: params.slug }
+  );
+}
+async function waitForHydration(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS3;
+  const outcome = await pollUntil(
+    async () => {
+      const { dataSources } = await list8(ctx);
+      const source2 = dataSources.find((s) => s.slug === params.slug);
+      if (!source2) {
+        throw new Error(`Data source "${params.slug}" not found.`);
+      }
+      return source2;
+    },
+    (source2) => !source2.hydration || source2.hydration.error !== null,
+    {
+      timeoutMs,
+      pollMs: POLL_MS4,
+      describe: (source2, start2) => `loading\u2026 ${source2.hydration.copied}/${source2.hydration.total} documents (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
+    }
+  );
+  const source = outcome.value;
+  const hydration = source.hydration;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      source,
+      error: timedOut(
+        timeoutMs,
+        `with ${hydration.copied}/${hydration.total} documents loaded`
+      )
+    };
+  }
+  if (hydration?.error) {
+    return { status: "failed", source, error: hydration.error };
+  }
+  return { status: "done", source };
+}
+function sample(ctx, params) {
+  const { slug, size, as, filter, stratify, placement } = params;
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/sample`,
+    {
+      slug,
+      size,
+      ...as ? { as } : {},
+      ...filter ? { filter } : {},
+      ...stratify ? { stratify } : {},
+      ...placement !== void 0 ? { placement } : {}
+    }
+  );
+}
+function createSet(ctx, params) {
+  const { slug, name, description, size, style, modelId, tags, seed } = params;
+  return call(ctx, "POST", `${base4(ctx.appId)}/eval/sets`, {
+    slug,
+    name,
+    ...description ? { description } : {},
+    ...size !== void 0 ? { size } : {},
+    ...style ? { style } : {},
+    ...modelId ? { modelId } : {},
+    ...tags?.length ? { tags } : {},
+    ...seed !== void 0 ? { seed } : {}
+  });
+}
+function listSets(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/sets${qs({ slug: params?.slug })}`
+  );
+}
+function getSet(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}${qs({
+      queries: params.queries ? "true" : void 0
+    })}`
+  );
+}
+function deleteSet(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/delete`
+  );
+}
+function addQueries(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/queries`,
+    { queries: params.queries }
+  );
+}
+function listQueries(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/queries`
+  );
+}
+function deleteQuery(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base4(ctx.appId)}/eval/sets/${encodeURIComponent(params.id)}/queries/delete`,
+    { queryId: params.queryId }
+  );
+}
+function run(ctx, params) {
+  const { setId, slug, candidate, label, retrieval } = params;
+  return call(ctx, "POST", `${base4(ctx.appId)}/eval/runs`, {
+    setId,
+    ...slug ? { slug } : {},
+    ...candidate ? { candidate: true } : {},
+    ...label ? { label } : {},
+    ...retrieval && Object.keys(retrieval).length ? { retrieval } : {}
+  });
+}
+function listRuns(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/runs${qs({ setId: params?.setId, slug: params?.slug })}`
+  );
+}
+function getRun(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/runs/${encodeURIComponent(params.id)}${qs({
+      queries: params.queries ? "true" : void 0,
+      worst: params.worst
+    })}`
+  );
+}
+function compare(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base4(ctx.appId)}/eval/runs/compare${qs({ a: params.a, b: params.b })}`
+  );
+}
+async function waitForRun(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS3;
+  const outcome = await pollUntil(
+    async () => (await getRun(ctx, { id: params.id })).run,
+    (run4) => run4.state === "done" || run4.state === "failed",
+    {
+      timeoutMs,
+      pollMs: POLL_MS4,
+      describe: (run4, start2) => `${run4.state}\u2026 ${run4.completed}/${run4.total} queries (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
+    }
+  );
+  const run3 = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      run: run3,
+      error: timedOut(
+        timeoutMs,
+        `; run is ${run3.state} (${run3.completed}/${run3.total})`
+      )
+    };
+  }
+  if (run3.state === "failed") {
+    return { status: "failed", run: run3, error: run3.error ?? "The run failed." };
+  }
+  return { status: "done", run: run3 };
+}
+async function waitForSet(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS3;
+  const outcome = await pollUntil(
+    async () => (await getSet(ctx, { id: params.id })).set,
+    (set4) => set4.state === "ready" || set4.state === "failed",
+    {
+      timeoutMs,
+      pollMs: POLL_MS4,
+      describe: (set4, start2) => `${set4.state}\u2026 (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
+    }
+  );
+  const set3 = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      set: set3,
+      error: timedOut(timeoutMs, `; set is still ${set3.state}`)
+    };
+  }
+  if (set3.state === "failed") {
+    return { status: "failed", set: set3, error: set3.error ?? "Generation failed." };
+  }
+  return { status: "done", set: set3 };
+}
+
+// src/commands/dataSourceEvals.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var dataSourceEvalsSpecs = {
+  "datasources hydrate": {
+    usage: "Usage: remy-admin datasources hydrate [--source <slug>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  },
+  "datasources sample": {
+    usage: "Usage: remy-admin datasources sample --source <slug> --size <n> [--as <slug>] [--filter <k=v,...|json>] [--stratify <metadata-key>] [--placement <resource-id|shared>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      size: { type: "number", min: 1 },
+      as: { type: "string" },
+      filter: { type: "string" },
+      stratify: { type: "string" },
+      placement: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["size"],
+      message: "--size <n> is required (documents to draw, up to 2000)."
+    }
+  },
+  "datasources eval create": {
+    usage: "Usage: remy-admin datasources eval create --source <slug> --name <name> [--size <n>] [--style cloze|question] [--model <id>] [--tags <a,b>] [--description <text>] [--seed <n>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      name: { type: "string" },
+      size: { type: "number", min: 0 },
+      style: { type: "string" },
+      model: { type: "string" },
+      tags: { type: "string" },
+      description: { type: "string" },
+      seed: { type: "number", min: 0 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: { flags: ["name"], message: "--name is required." }
+  },
+  "datasources eval list": {
+    usage: "Usage: remy-admin datasources eval list [--source <slug>]",
+    flags: { source: { type: "string" } }
+  },
+  "datasources eval get": {
+    usage: "Usage: remy-admin datasources eval get <setId> [--queries]",
+    positionals: [{ name: "id", required: true }],
+    flags: { queries: { type: "boolean" } }
+  },
+  "datasources eval delete": {
+    usage: "Usage: remy-admin datasources eval delete <setId>",
+    positionals: [{ name: "id", required: true }]
+  },
+  "datasources eval add": {
+    usage: "Usage: remy-admin datasources eval add --set <id> --query <text> (--expect <ref,...> | --expect-file <name,...> | --expect-external <id,...>) [--passage <text>] [--tags <a,b>]",
+    flags: {
+      set: { type: "string" },
+      query: { type: "string" },
+      expect: { type: "string" },
+      "expect-file": { type: "string" },
+      "expect-external": { type: "string" },
+      passage: { type: "string" },
+      tags: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["expect", "expect-file", "expect-external"],
+      message: "Say which document should come back: --expect <documentId|filename|externalId,...>, --expect-file <filename,...> or --expect-external <externalId,...>."
+    }
+  },
+  "datasources eval import": {
+    usage: "Usage: remy-admin datasources eval import --set <id> <file.jsonl>",
+    positionals: [{ name: "file", required: true }],
+    flags: { set: { type: "string" } }
+  },
+  "datasources eval queries": {
+    usage: "Usage: remy-admin datasources eval queries --set <id>",
+    flags: { set: { type: "string" } }
+  },
+  "datasources eval rm": {
+    usage: "Usage: remy-admin datasources eval rm --set <id> <queryId>",
+    positionals: [{ name: "queryId", required: true }],
+    flags: { set: { type: "string" } }
+  },
+  "datasources eval run": {
+    usage: "Usage: remy-admin datasources eval run --set <id> [--source <slug>] [--candidate] [--label <text>] [--mode hybrid|semantic|lexical] [--rerank true|false] [--rerank-model <id>] [--candidates <n>] [--hybrid true|false] [--top-k <n>] [--wait] [--timeout <sec>]",
+    flags: {
+      set: { type: "string" },
+      source: { type: "string" },
+      candidate: { type: "boolean" },
+      label: { type: "string" },
+      mode: { type: "string" },
+      rerank: { type: "string" },
+      "rerank-model": { type: "string" },
+      candidates: { type: "number", min: 1 },
+      hybrid: { type: "string" },
+      "top-k": { type: "number", min: 1 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: { flags: ["set"], message: "--set <id> is required." }
+  },
+  "datasources eval runs": {
+    usage: "Usage: remy-admin datasources eval runs [--set <id>] [--source <slug>]",
+    flags: { set: { type: "string" }, source: { type: "string" } }
+  },
+  "datasources eval result": {
+    usage: "Usage: remy-admin datasources eval result <runId> [--queries] [--worst <n>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { queries: { type: "boolean" }, worst: { type: "number", min: 1 } }
+  },
+  "datasources eval compare": {
+    usage: "Usage: remy-admin datasources eval compare <runA> <runB>",
+    positionals: [
+      { name: "a", required: true },
+      { name: "b", required: true }
+    ]
+  }
+};
+var requireSet = (a) => {
+  const id = a.str("set");
+  if (!id) {
+    fatal("--set <id> is required.");
+  }
+  return id;
+};
+var splitList = (raw) => (raw ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+var triState = (a, flag) => {
+  const raw = a.str(flag);
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw !== "true" && raw !== "false") {
+    fatal(`--${flag} must be "true" or "false" (got "${raw}").`);
+  }
+  return raw === "true";
+};
+function selectorFromFlag(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw.trimStart().startsWith("{")) {
+    try {
+      return JSON.parse(raw);
+    } catch (err) {
+      fatal(`--filter is not valid JSON: ${err.message}`);
+    }
+  }
+  const metadata = {};
+  for (const part of raw.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) {
+      fatal(`--filter entries must be key=value (got "${trimmed}").`);
+    }
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim();
+    metadata[key] = value === "true" ? true : value === "false" ? false : value !== "" && !Number.isNaN(Number(value)) ? Number(value) : value;
+  }
+  return { metadata };
+}
+async function hydrate2(ctx, a) {
+  const slug = a.str("source") || DEFAULT_SOURCE;
+  const started = await hydrate(ctx, { slug });
+  if (started.resident || !a.bool("wait")) {
+    out({
+      dataSource: slug,
+      ...started,
+      ...started.resident ? { note: "The index is already loaded." } : {
+        note: "Loading in the background. `datasources list` shows progress; re-run with --wait to block."
+      }
+    });
+    return;
+  }
+  const result = await waitForHydration(ctx, {
+    slug,
+    ...timeoutOf(a),
+    onProgress: progress
+  });
+  out({ dataSource: slug, action: "hydrate", ...result });
+  failOnWait(result);
+}
+async function sampleCmd(ctx, a) {
+  const slug = a.str("source");
+  if (!slug) {
+    fatal("--source is required \u2014 a sample is drawn from one named source.");
+  }
+  const placementRaw = a.str("placement");
+  const placement = placementRaw === void 0 ? void 0 : placementRaw === "shared" ? "shared" : { resourceId: placementRaw };
+  const result = await sample(ctx, {
+    slug,
+    size: a.num("size"),
+    ...a.str("as") ? { as: a.str("as") } : {},
+    ...a.str("filter") ? { filter: selectorFromFlag(a.str("filter")) } : {},
+    ...a.str("stratify") ? { stratify: a.str("stratify") } : {},
+    ...placement !== void 0 ? { placement } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      ...result,
+      note: `Sampling into "${result.dataSource.slug}". Poll \`datasources jobs status ${result.job.id}\` or re-run with --wait.`
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, result.job.id, "job", {
+    dataSource: result.dataSource,
+    action: "sample"
+  });
+}
+async function evalCreate(ctx, a) {
+  const slug = a.str("source") || DEFAULT_SOURCE;
+  const style = a.str("style");
+  if (style && style !== "cloze" && style !== "question") {
+    fatal(`--style must be "cloze" or "question" (got "${style}").`);
+  }
+  const size = a.num("size");
+  const seed = a.num("seed");
+  const { set: set3 } = await createSet(ctx, {
+    slug,
+    name: a.str("name"),
+    ...a.str("description") ? { description: a.str("description") } : {},
+    ...size !== void 0 ? { size } : {},
+    ...style ? { style } : {},
+    ...a.str("model") ? { modelId: a.str("model") } : {},
+    ...a.str("tags") ? { tags: splitList(a.str("tags")) } : {},
+    ...seed !== void 0 ? { seed } : {}
+  });
+  const generating = set3.state === "queued" || set3.state === "generating";
+  if (!generating || !a.bool("wait")) {
+    out({
+      dataSource: slug,
+      set: set3,
+      note: generating ? "Generating in the background. `datasources eval get <id>` shows the state; re-run with --wait to block." : "Empty set. Add queries with `datasources eval add` or `eval import`."
+    });
+    return;
+  }
+  const result = await waitForSet(ctx, {
+    id: set3.id,
+    ...timeoutOf(a),
+    onProgress: progress
+  });
+  out({ dataSource: slug, action: "create", ...result });
+  failOnWait(result);
+}
+async function evalList(ctx, a) {
+  const slug = a.str("source");
+  out(await listSets(ctx, slug ? { slug } : void 0));
+}
+async function evalGet(ctx, a) {
+  out(
+    await getSet(ctx, {
+      id: a.req("id"),
+      ...a.bool("queries") ? { queries: true } : {}
+    })
+  );
+}
+async function evalDelete(ctx, a) {
+  out(await deleteSet(ctx, { id: a.req("id") }));
+}
+function expectFromFlags(a) {
+  const expect = {};
+  for (const ref of splitList(a.str("expect"))) {
+    if (UUID_RE.test(ref)) {
+      (expect.documentIds ??= []).push(ref);
+    } else if (ref.includes(".")) {
+      (expect.filenames ??= []).push(ref);
+    } else {
+      (expect.externalIds ??= []).push(ref);
+    }
+  }
+  for (const name of splitList(a.str("expect-file"))) {
+    (expect.filenames ??= []).push(name);
+  }
+  for (const id of splitList(a.str("expect-external"))) {
+    (expect.externalIds ??= []).push(id);
+  }
+  return expect;
+}
+async function evalAdd(ctx, a) {
+  const id = requireSet(a);
+  const query3 = a.str("query");
+  if (!query3) {
+    fatal("--query is required.");
+  }
+  const result = await addQueries(ctx, {
+    id,
+    queries: [
+      {
+        query: query3,
+        expect: expectFromFlags(a),
+        ...a.str("passage") ? { passage: a.str("passage") } : {},
+        ...a.str("tags") ? { tags: splitList(a.str("tags")) } : {}
+      }
+    ]
+  });
+  out({ set: id, ...result });
+}
+async function evalImport(ctx, a) {
+  const id = requireSet(a);
+  const file = a.req("file");
+  const abs = path3.isAbsolute(file) ? file : path3.join(WORKSPACE_DIR, file);
+  let content;
+  try {
+    content = fs3.readFileSync(abs, "utf8");
+  } catch (err) {
+    fatal(`Could not read "${file}": ${err.message}`);
+  }
+  const rows = [];
+  content.split("\n").forEach((line, i) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      fatal(`${file}:${i + 1} is not valid JSON.`);
+    }
+    if (typeof parsed?.query !== "string" || typeof parsed?.expect !== "object") {
+      fatal(
+        `${file}:${i + 1} needs { "query": "...", "expect": { "filenames" | "documentIds" | "externalIds" | "contentHashes": [...] } }.`
+      );
+    }
+    rows.push(parsed);
+  });
+  if (rows.length === 0) {
+    fatal(`"${file}" has no queries.`);
+  }
+  let added = 0;
+  let queryCount = 0;
+  for (let i = 0; i < rows.length; i += 500) {
+    progress(`importing ${Math.min(i + 500, rows.length)}/${rows.length}\u2026`);
+    const result = await addQueries(ctx, {
+      id,
+      queries: rows.slice(i, i + 500)
+    });
+    added += result.added;
+    queryCount = result.queryCount;
+  }
+  out({ set: id, added, queryCount });
+}
+async function evalQueries(ctx, a) {
+  out(await listQueries(ctx, { id: requireSet(a) }));
+}
+async function evalRm(ctx, a) {
+  out(
+    await deleteQuery(ctx, {
+      id: requireSet(a),
+      queryId: a.req("queryId")
+    })
+  );
+}
+async function evalRun(ctx, a) {
+  const mode = a.str("mode");
+  if (mode && !["hybrid", "semantic", "lexical"].includes(mode)) {
+    fatal(`--mode must be "hybrid", "semantic" or "lexical" (got "${mode}").`);
+  }
+  const rerank = triState(a, "rerank");
+  const hybrid = triState(a, "hybrid");
+  const rerankModel = a.str("rerank-model");
+  const candidates = a.num("candidates");
+  const topK = a.num("top-k");
+  const retrieval = {
+    ...mode ? { mode } : {},
+    ...hybrid !== void 0 ? { hybrid } : {},
+    ...rerank !== void 0 || rerankModel || candidates !== void 0 ? {
+      rerank: {
+        ...rerank !== void 0 ? { enabled: rerank } : {},
+        ...rerankModel ? { modelId: rerankModel } : {},
+        ...candidates !== void 0 ? { candidates } : {}
+      }
+    } : {},
+    ...topK !== void 0 ? { topK } : {}
+  };
+  const { run: run3 } = await run(ctx, {
+    setId: a.str("set"),
+    ...a.str("source") ? { slug: a.str("source") } : {},
+    ...a.bool("candidate") ? { candidate: true } : {},
+    ...a.str("label") ? { label: a.str("label") } : {},
+    retrieval
+  });
+  if (!a.bool("wait")) {
+    out({
+      run: run3,
+      note: "Running in the background. `datasources eval result <id>` shows the numbers when it is done; re-run with --wait to block."
+    });
+    return;
+  }
+  const result = await waitForRun(ctx, {
+    id: run3.id,
+    ...timeoutOf(a),
+    onProgress: progress
+  });
+  out({ action: "run", ...result });
+  failOnWait(result);
+}
+async function evalRuns(ctx, a) {
+  const setId = a.str("set");
+  const slug = a.str("source");
+  out(
+    await listRuns(ctx, {
+      ...setId ? { setId } : {},
+      ...slug ? { slug } : {}
+    })
+  );
+}
+async function evalResult(ctx, a) {
+  const worst = a.num("worst");
+  out(
+    await getRun(ctx, {
+      id: a.req("id"),
+      ...a.bool("queries") ? { queries: true } : {},
+      ...worst !== void 0 ? { worst } : {}
+    })
+  );
+}
+async function evalCompare(ctx, a) {
+  out(await compare(ctx, { a: a.req("a"), b: a.req("b") }));
+}
+var dataSourceEvalsHandlers = {
+  "datasources hydrate": hydrate2,
+  "datasources sample": sampleCmd,
+  "datasources eval create": evalCreate,
+  "datasources eval list": evalList,
+  "datasources eval get": evalGet,
+  "datasources eval delete": evalDelete,
+  "datasources eval add": evalAdd,
+  "datasources eval import": evalImport,
+  "datasources eval queries": evalQueries,
+  "datasources eval rm": evalRm,
+  "datasources eval run": evalRun,
+  "datasources eval runs": evalRuns,
+  "datasources eval result": evalResult,
+  "datasources eval compare": evalCompare
+};
+var dataSourceEvalsHelp = `
+Warming and sampling:
+  remy-admin datasources hydrate [--source <slug>] [--wait]
+  remy-admin datasources sample --source <slug> --size <n> [--as <slug>] [--filter <k=v,...|json>] [--stratify <key>] [--placement <id|shared>] [--wait]
+
+  A large source whose index was evicted (the shared pool holds a working set,
+  not everything) answers searches with index_warming while it reloads in the
+  background; small sources reload inside the search and never show it.
+  \`hydrate\` starts that reload ahead of time \u2014 before a demo, say \u2014 and
+  \`--wait\` blocks until the index is back. \`datasources list\` shows the
+  reload's progress under \`hydration\`.
+
+  \`sample\` draws documents from a source into a new one that shares its
+  exact pinned config, so what you measure on the sample says something about
+  the parent. Uniform by default; --stratify <metadata key> takes each value
+  in proportion; --filter scopes the draw. It runs as a job (auto-approved;
+  extraction is reused, so the plan is chunk + embed only). Documents keep
+  their content hashes, which is what lets a query set built on the sample
+  score the parent as well. Up to 2,000 documents.
+
+Retrieval evals:
+  remy-admin datasources eval create --source <slug> --name <name> [--size <n>] [--style cloze|question] [--model <id>] [--tags <a,b>] [--wait]
+  remy-admin datasources eval list [--source <slug>]
+  remy-admin datasources eval get <setId> [--queries]
+  remy-admin datasources eval add --set <id> --query <text> --expect <ref,...> [--passage <text>] [--tags <a,b>]
+  remy-admin datasources eval import --set <id> <file.jsonl>
+  remy-admin datasources eval queries --set <id>
+  remy-admin datasources eval rm --set <id> <queryId>
+  remy-admin datasources eval delete <setId>
+  remy-admin datasources eval run --set <id> [--source <slug>] [--candidate] [--label <text>] [retrieval options] [--wait]
+  remy-admin datasources eval runs [--set <id>] [--source <slug>]
+  remy-admin datasources eval result <runId> [--queries] [--worst <n>]
+  remy-admin datasources eval compare <runA> <runB>
+
+  A query SET is a list of questions with the documents that should come
+  back. \`create --size N\` generates them from the corpus: the default
+  \`cloze\` style holds one sentence out of a chunk and uses it as the query
+  (free and deterministic, but it flatters keyword matching \u2014 a real user
+  does not type sentences from the document); \`--style question\` has a
+  chat model write the question a user would ask (a model call per query,
+  cost recorded on the set). Both record the document AND the chunk that
+  answers, and both skip sentences that restate the title. Add real user
+  questions with \`add\` (--expect takes document ids, filenames or external
+  ids, comma-separated; every reference must exist) or \`import\` a JSONL of
+  {"query","expect":{"filenames":[...]},"passage"?,"tags"?}.
+
+  A RUN scores a set against one target: the set's own source by default,
+  --source another (the parent of a sample, or a sample of the parent \u2014
+  expectations resolve by content hash), --candidate the target's candidate
+  version. Every query is a real search through the same code apps use, ten
+  results deep, with explain on. Retrieval options override the target's
+  live config for the run only: --mode, --rerank true|false, --rerank-model
+  <id>, --candidates <n>, --hybrid true|false, --top-k <n>. Runs are capped
+  at 2,000 queries and cost what 2,000 searches cost.
+
+  \`result\` prints the aggregates \u2014 recall@1/5/10, chunk recall, MRR,
+  nDCG@10, latency p50/p95, cost per query, how often reranking ran, and
+  which branch (dense, lexical, both) found the expected document, per tag
+  too \u2014 plus \`--worst N\` for the queries that missed and what came back
+  instead, or \`--queries\` for every row. \`compare\` puts two runs side by
+  side with deltas and, when they share a set, per-query wins and losses.
+  The output is JSON; the table is yours to write.
+
+  The workflow: sample the source, create a set on the sample, run it against
+  the live version, revectorize with the change you want to test, run again
+  with --candidate, compare, promote or drop.
+`;
+
+// src/commands/dataSourceJobs.ts
+import fs4 from "fs";
+import path4 from "path";
+var dataSourceJobsSpecs = {
+  "datasources jobs start": {
+    usage: "Usage: remy-admin datasources jobs start [--source <slug>] (--store <name> [--access <private|public>] [--prefix <p>] | --manifest <file.jsonl>) [--limit <n>] [--budget <dollars>] [--concurrency <n>] [--approve] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      store: { type: "string" },
+      access: { type: "string" },
+      prefix: { type: "string" },
+      manifest: { type: "string" },
+      limit: { type: "number", min: 1 },
+      budget: { type: "number", min: 0.01 },
+      concurrency: { type: "number", min: 1 },
+      approve: { type: "boolean" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["store", "manifest"],
+      message: "Give the job something to read: --store <name> [--prefix <p>], or --manifest <file.jsonl>."
+    }
+  },
+  "datasources jobs list": {
+    usage: "Usage: remy-admin datasources jobs list [--source <slug>]",
+    flags: { source: { type: "string" } }
+  },
+  "datasources jobs status": {
+    usage: "Usage: remy-admin datasources jobs status <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "datasources jobs approve": {
+    usage: "Usage: remy-admin datasources jobs approve <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "datasources jobs pause": {
+    usage: "Usage: remy-admin datasources jobs pause <id>",
+    positionals: [{ name: "id", required: true }]
+  },
+  "datasources jobs resume": {
+    usage: "Usage: remy-admin datasources jobs resume <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "datasources jobs cancel": {
+    usage: "Usage: remy-admin datasources jobs cancel <id>",
+    positionals: [{ name: "id", required: true }]
+  }
+};
+async function jobsStart(ctx, a) {
+  const slug = sourceOf(a);
+  const store = a.str("store");
+  const manifest = a.str("manifest");
+  if (store && manifest) {
+    fatal("Give --store or --manifest, not both.");
+  }
+  let source;
+  if (manifest) {
+    const abs = path4.isAbsolute(manifest) ? manifest : path4.join(WORKSPACE_DIR, manifest);
+    let content;
+    try {
+      content = fs4.readFileSync(abs);
+    } catch (err) {
+      fatal(`Could not read manifest "${manifest}": ${err.message}`);
+    }
+    progress(`uploading manifest (${(content.length / 1024).toFixed(0)} KB)\u2026`);
+    const { key } = await uploadManifest(ctx, { slug, content });
+    source = { type: "manifest", key };
+  } else {
+    const access = a.str("access") ?? "private";
+    if (access !== "private" && access !== "public") {
+      fatal(`--access must be "private" or "public" (got "${access}").`);
+    }
+    source = {
+      type: "store",
+      store,
+      access,
+      prefix: a.str("prefix") ?? ""
+    };
+  }
+  const budget = a.num("budget");
+  const concurrency = a.num("concurrency");
+  const limit = a.num("limit");
+  const { job } = await start(ctx, {
+    slug,
+    source,
+    ...a.bool("approve") ? { approve: true } : {},
+    ...budget !== void 0 ? { budgetDollars: budget } : {},
+    ...concurrency !== void 0 ? { concurrency } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: slug,
+      job,
+      note: job.autoApprove ? "Planning, then running once the plan passes the gates. Poll `datasources jobs status <id>` or re-run with --wait." : "Planning. When the plan is ready, review it with `datasources jobs status <id>` and run `datasources jobs approve <id>`."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, job.autoApprove ? "job" : "plan", {
+    dataSource: slug,
+    action: "start",
+    ...job.autoApprove ? {} : { note: "Review the plan, then `datasources jobs approve <id>`." }
+  });
+}
+async function jobsList(ctx, a) {
+  const slug = a.str("source");
+  out(await list9(ctx, slug ? { slug } : void 0));
+}
+async function jobsStatus(ctx, a) {
+  const id = a.req("id");
+  if (!a.bool("wait")) {
+    out(await get7(ctx, { id }));
+    return;
+  }
+  await waitAndReport(ctx, a, id, "job", { action: "status" });
+}
+async function jobsApprove(ctx, a) {
+  const id = a.req("id");
+  const { job } = await approve(ctx, { id });
+  if (!a.bool("wait")) {
+    out({
+      job,
+      note: "Running. Poll `datasources jobs status <id>` or re-run with --wait."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, id, "job", { action: "approve" });
+}
+async function jobsPause(ctx, a) {
+  out(await pause(ctx, { id: a.req("id") }));
+}
+async function jobsResume(ctx, a) {
+  const id = a.req("id");
+  const { job } = await resume(ctx, { id });
+  if (!a.bool("wait")) {
+    out({ job });
+    return;
+  }
+  await waitAndReport(ctx, a, id, "job", { action: "resume" });
+}
+async function jobsCancel(ctx, a) {
+  out(await cancel(ctx, { id: a.req("id") }));
+}
+var dataSourceJobsHandlers = {
+  "datasources jobs start": jobsStart,
+  "datasources jobs list": jobsList,
+  "datasources jobs status": jobsStatus,
+  "datasources jobs approve": jobsApprove,
+  "datasources jobs pause": jobsPause,
+  "datasources jobs resume": jobsResume,
+  "datasources jobs cancel": jobsCancel
+};
+var dataSourceJobsHelp = `
+Bulk ingestion (jobs):
+  remy-admin datasources jobs start [--source <slug>] --store <name> [--access <private|public>] [--prefix <p>] [options]
+  remy-admin datasources jobs start [--source <slug>] --manifest <file.jsonl> [options]
+  remy-admin datasources jobs list [--source <slug>]
+  remy-admin datasources jobs status <id> [--wait] [--timeout <sec>]
+  remy-admin datasources jobs approve <id> [--wait] [--timeout <sec>]
+  remy-admin datasources jobs pause|resume|cancel <id>
+
+  A job loads a whole corpus at once. It reads either every object under a
+  prefix of one of the app's file stores (\`files put\` fills one; an app can
+  write one at runtime) or a manifest you upload: JSONL, one line per document,
+  {"url": "https://\u2026", "filename": "x.pdf", "externalId": "\u2026", "metadata": {\u2026}}.
+  filename, externalId and metadata are optional; the URL must be public.
+
+  Nothing is spent until you say so. The platform counts the source, reads a
+  sample of about a hundred documents, and writes a plan: documents, chunks,
+  cost per stage (embedding, extraction, contextual) at today's rates, storage,
+  whether it fits where the source lives, and a duration. \`jobs status\` shows
+  it; \`jobs approve\` starts the run. Two gates: the corpus has to fit the
+  source's placement (a shared-pool source over the per-source cap answers
+  plan_requires_dedicated: place it on dedicated capacity first), and the
+  workspace has to be able to cover the projection (insufficient_credits).
+
+  Options on start:
+    --approve          Run as soon as the plan passes the gates, no separate approve
+    --budget <dollars> Pause when estimated spend reaches this (default 1.5x the plan)
+    --concurrency <n>  Batches in flight at once (default 8, max 64)
+    --limit <n>        Only the first N objects: a cheap sample of the corpus
+    --wait             Block until the plan is ready (or, with --approve, until done)
+
+  While running, documents are read in batches of fifty with one embedding
+  call per batch. Unchanged documents are skipped by content hash, so re-running
+  a job over the same source costs nothing new. Per-document failures are kept
+  on the job (\`jobs status\` lists the last twenty) and the run continues; five
+  failed batches in a row pause it, as does the budget. \`jobs resume\` continues
+  from the checkpoint and retries failed batches; \`jobs cancel\` stops it and
+  keeps what was indexed. Search works on the partial corpus throughout.
+
+  One bulk operation per source: a job refuses to start during a move or while
+  a candidate version exists, and moves, re-vectorizes and deletes refuse while
+  a job is in flight (data_source_busy). Interactive \`add\` keeps working.
+
+  --wait exit codes: 0 done \xB7 1 the job failed, paused, was cancelled, or sits
+  in planned because a gate refused it (approve once the cause is fixed) \xB7
+  2 still running when --timeout elapsed (default 3600s).
+`;
+
+// src/ops/dataSourceMappers.ts
+function base5(appId) {
+  return `/_internal/v2/apps/${appId}/datasources`;
+}
+function selectionBody(selection) {
+  if ("connector" in selection) {
+    return { connector: true };
+  }
+  return {
+    store: selection.store,
+    ...selection.access ? { access: selection.access } : {},
+    ...selection.prefix !== void 0 ? { prefix: selection.prefix } : {}
+  };
+}
+function inspect(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base(ctx.appId)}/revectorize`,
+    `${base5(ctx.appId)}/inspect`,
     {
-      slug,
-      ...ingest ? { ingest } : {}
+      ...params.slug ? { slug: params.slug } : {},
+      ...selectionBody(params.selection),
+      ...params.keys ? { keys: params.keys } : {},
+      ...params.limit !== void 0 ? { limit: params.limit } : {}
     }
   );
 }
-function promote(ctx, params) {
+function mapTest(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base(ctx.appId)}/promote`,
+    `${base5(ctx.appId)}/map-test`,
     {
       slug: params.slug,
-      ...params.force ? { force: true } : {}
+      ...selectionBody(params.selection),
+      ...params.keys ? { keys: params.keys } : {},
+      ...params.limit !== void 0 ? { limit: params.limit } : {},
+      ...params.dev ? { dev: true } : {}
     }
   );
 }
-function drop(ctx, params) {
+function mapDeploy(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base(ctx.appId)}/versions/drop`,
+    `${base5(ctx.appId)}/mapper/deploy`,
     {
       slug: params.slug,
-      ...params.version !== void 0 ? { version: params.version } : {}
+      ...params.releaseId ? { releaseId: params.releaseId } : {}
     }
   );
 }
-function rm(ctx, params) {
+function remap(ctx, params) {
+  return call(ctx, "POST", `${base5(ctx.appId)}/remap`, {
+    slug: params.slug,
+    ...params.budgetDollars !== void 0 ? { budgetDollars: params.budgetDollars } : {},
+    ...params.limit !== void 0 ? { limit: params.limit } : {}
+  });
+}
+function quarantine(ctx, params) {
   return call(
     ctx,
-    "POST",
-    `${base(ctx.appId)}/documents/delete`,
-    {
-      slug: params.slug,
-      documentId: params.documentId
-    }
+    "GET",
+    `${base5(ctx.appId)}/jobs/${params.id}/quarantine${qs({
+      ...params.kind ? { kind: params.kind } : {},
+      ...params.reason ? { reason: params.reason } : {},
+      ...params.cursor ? { cursor: params.cursor } : {},
+      ...params.limit !== void 0 ? { limit: params.limit } : {}
+    })}`
   );
 }
-function deleteSource(ctx, slug) {
+function replay(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base(ctx.appId)}/delete`,
-    { slug }
+    `${base5(ctx.appId)}/jobs/${params.id}/replay`,
+    params.kind ? { kind: params.kind } : {}
+  );
+}
+
+// src/commands/dataSourceMappers.ts
+var SELECTION_FLAGS = {
+  store: { type: "string" },
+  access: { type: "string" },
+  prefix: { type: "string" },
+  connector: { type: "boolean" },
+  keys: { type: "string" }
+};
+var dataSourceMappersSpecs = {
+  "datasources inspect": {
+    usage: "Usage: remy-admin datasources inspect [--source <slug>] (--store <name> [--access <private|public>] [--prefix <p>] | --connector) [--keys k1,k2,...] [--limit <n>]",
+    flags: {
+      source: { type: "string" },
+      ...SELECTION_FLAGS,
+      limit: { type: "number", min: 1 }
+    },
+    requireAnyOf: {
+      flags: ["store", "connector"],
+      message: "Name the objects: --store <name> [--prefix <p>], or --connector for the source's bucket."
+    }
+  },
+  "datasources map test": {
+    usage: "Usage: remy-admin datasources map test [--source <slug>] (--store <name> [--access <private|public>] [--prefix <p>] | --connector) [--keys k1,k2,...] [--limit <n>] [--dev] [--full]",
+    flags: {
+      source: { type: "string" },
+      ...SELECTION_FLAGS,
+      limit: { type: "number", min: 1 },
+      dev: { type: "boolean" },
+      full: { type: "boolean" }
+    },
+    requireAnyOf: {
+      flags: ["store", "connector"],
+      message: "Name the objects: --store <name> [--prefix <p>], or --connector for the source's bucket."
+    }
+  },
+  "datasources map deploy": {
+    usage: "Usage: remy-admin datasources map deploy [--source <slug>] [--release <id>]",
+    flags: {
+      source: { type: "string" },
+      release: { type: "string" }
+    }
+  },
+  "datasources remap": {
+    usage: "Usage: remy-admin datasources remap [--source <slug>] [--budget <dollars>] [--limit <n>] [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      budget: { type: "number", min: 0.01 },
+      limit: { type: "number", min: 1 },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  },
+  "datasources jobs quarantine": {
+    usage: "Usage: remy-admin datasources jobs quarantine <id> [--kind skip|error] [--reason <text>] [--cursor <id>] [--limit <n>]",
+    positionals: [{ name: "id", required: true }],
+    flags: {
+      kind: { type: "string" },
+      reason: { type: "string" },
+      cursor: { type: "string" },
+      limit: { type: "number", min: 1 }
+    }
+  },
+  "datasources jobs replay": {
+    usage: "Usage: remy-admin datasources jobs replay <id> [--kind skip|error] [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: {
+      kind: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    }
+  }
+};
+function selectionOf(a) {
+  const store = a.str("store");
+  if (a.bool("connector") && store) {
+    fatal("Give --store or --connector, not both.");
+  }
+  if (a.bool("connector")) {
+    return { connector: true };
+  }
+  const access = a.str("access") ?? "private";
+  if (access !== "private" && access !== "public") {
+    fatal(`--access must be "private" or "public" (got "${access}").`);
+  }
+  return {
+    store,
+    access,
+    ...a.str("prefix") !== void 0 ? { prefix: a.str("prefix") } : {}
+  };
+}
+function keysOf(a) {
+  const raw = a.str("keys");
+  if (!raw) {
+    return void 0;
+  }
+  const keys = raw.split(",").map((k) => k.trim()).filter(Boolean);
+  if (keys.length === 0) {
+    fatal("--keys needs at least one key.");
+  }
+  return keys;
+}
+function kindOf(a) {
+  const kind = a.str("kind");
+  if (kind === void 0) {
+    return void 0;
+  }
+  if (kind !== "skip" && kind !== "error") {
+    fatal(`--kind must be "skip" or "error" (got "${kind}").`);
+  }
+  return kind;
+}
+async function inspect2(ctx, a) {
+  const slug = a.str("source");
+  const selection = selectionOf(a);
+  if ("connector" in selection && !slug) {
+    fatal("--connector needs --source: the bucket is the source's.");
+  }
+  const limit = a.num("limit");
+  const result = await inspect(ctx, {
+    ...slug ? { slug } : {},
+    selection,
+    ...keysOf(a) ? { keys: keysOf(a) } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  out({
+    ...slug ? { dataSource: slug } : {},
+    ...result,
+    note: result.report.truncated ? `Listed the first ${result.report.objects.toLocaleString()} objects; raise --limit to see more of the shape.` : `Listed every object (${result.report.objects.toLocaleString()}).`
+  });
+}
+async function mapTest2(ctx, a) {
+  const slug = sourceOf(a);
+  const limit = a.num("limit");
+  const result = await mapTest(ctx, {
+    slug,
+    selection: selectionOf(a),
+    ...keysOf(a) ? { keys: keysOf(a) } : {},
+    ...limit !== void 0 ? { limit } : {},
+    ...a.bool("dev") ? { dev: true } : {}
+  });
+  const results = a.bool("full") ? result.results : result.results.map(
+    (r) => r.outcome.kind === "documents" ? {
+      ...r,
+      outcome: {
+        ...r.outcome,
+        documents: r.outcome.documents.map((d) => ({
+          ...d,
+          preview: d.preview.slice(0, 200)
+        }))
+      }
+    } : r
   );
+  out({
+    dataSource: slug,
+    ...result,
+    results,
+    note: result.dev ? "Ran the LOCAL mapper through the dev session. Nothing was ingested; push a branch, wait for its build, then `datasources map deploy` to make it the source's mapper." : "Ran the source's active mapper. Nothing was ingested."
+  });
+  if (result.counts.error > 0) {
+    throw new CliError(
+      `${result.counts.error} of ${result.objects} object(s) errored in the mapper.`,
+      EXIT.buildFailed
+    );
+  }
+}
+async function mapDeploy2(ctx, a) {
+  const slug = sourceOf(a);
+  const releaseId = a.str("release");
+  const result = await mapDeploy(ctx, {
+    slug,
+    ...releaseId ? { releaseId } : {}
+  });
+  const { mapper } = result;
+  const from = `${mapper.branch ?? "release"} @ ${(mapper.commitSha ?? "").slice(0, 7)}`;
+  out({
+    dataSource: slug,
+    mapper,
+    changed: result.changed,
+    note: result.changed ? `Active: the mapper compiled by ${from}. Jobs, syncs and add() run it from now on; \`remap\` re-applies it to what is already loaded.` : `Already active: the mapper compiled by ${from}. Nothing changed.`
+  });
+}
+async function remap2(ctx, a) {
+  const slug = sourceOf(a);
+  const budget = a.num("budget");
+  const limit = a.num("limit");
+  const { job, mapper } = await remap(ctx, {
+    slug,
+    ...budget !== void 0 ? { budgetDollars: budget } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: slug,
+      job,
+      mapper,
+      note: "Remapping from the raw copies. Poll `datasources jobs status <id>`, or re-run with --wait. Unchanged documents are skipped by hash; changed ones supersede their predecessors."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, "job", {
+    dataSource: slug,
+    action: "remap",
+    mapper
+  });
+}
+async function quarantine2(ctx, a) {
+  const id = a.req("id");
+  const limit = a.num("limit");
+  const kind = kindOf(a);
+  const reason = a.str("reason");
+  const cursor = a.str("cursor");
+  const result = await quarantine(ctx, {
+    id,
+    ...kind ? { kind } : {},
+    ...reason ? { reason } : {},
+    ...cursor ? { cursor } : {},
+    ...limit !== void 0 ? { limit } : {}
+  });
+  out({
+    ...result,
+    note: result.counts.skipped + result.counts.errors === 0 ? "Nothing quarantined: the mapper produced documents (or deletions) for every object." : `Fix the mapper, push, \`datasources map deploy\`, then \`datasources jobs replay ${id}\` to run these through it again.`
+  });
+}
+async function replay2(ctx, a) {
+  const id = a.req("id");
+  const kind = kindOf(a);
+  const { job, mapper, dataSource } = await replay(ctx, {
+    id,
+    ...kind ? { kind } : {}
+  });
+  if (!a.bool("wait")) {
+    out({
+      dataSource: dataSource.slug,
+      fromJob: id,
+      job,
+      mapper,
+      note: "Replaying the quarantined objects through the current mapper. Poll `datasources jobs status <id>`, or re-run with --wait."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, job.id, "job", {
+    dataSource: dataSource.slug,
+    fromJob: id,
+    action: "replay",
+    mapper
+  });
 }
+var dataSourceMappersHandlers = {
+  "datasources inspect": inspect2,
+  "datasources map test": mapTest2,
+  "datasources map deploy": mapDeploy2,
+  "datasources remap": remap2,
+  "datasources jobs quarantine": quarantine2,
+  "datasources jobs replay": replay2
+};
+var dataSourceMappersHelp = `
+Mapping raw objects into documents (mappers):
+  remy-admin datasources inspect [--source <slug>] (--store <name> [--prefix <p>] | --connector) [--keys k1,k2] [--limit <n>]
+  remy-admin datasources map test [--source <slug>] (--store <name> [--prefix <p>] | --connector) [--keys k1,k2] [--limit <n>] [--dev] [--full]
+  remy-admin datasources map deploy [--source <slug>] [--release <id>]
+  remy-admin datasources remap [--source <slug>] [--budget <dollars>] [--limit <n>] [--wait] [--timeout <sec>]
+  remy-admin datasources jobs quarantine <id> [--kind skip|error] [--reason <text>] [--cursor <id>] [--limit <n>]
+  remy-admin datasources jobs replay <id> [--kind skip|error] [--wait] [--timeout <sec>]
+
+  A source takes every object it is given as one document. When the file is
+  not the document \u2014 JSON records that should become markdown plus metadata,
+  a JSONL object holding many articles, a kill notice that means "remove this
+  story" \u2014 the app declares a MAPPER for the source in mindstudio.json:
+    "dataSources": [{ "slug": "archive", "mapper": { "path": "dist/datasources/archive.mapper.ts" } }]
+  The file exports defineMapper(Archive, { map }) from @mindstudio-ai/agent.
+  map(object) reads the raw object (object.key, .bytes(), .text(), .json())
+  and answers documents([{ externalId, title, markdown, metadata?, replaces? }]),
+  passthrough() (ingest the raw object as-is), skip(reason) or
+  deletes([externalId, ...]); throwing is the object's error. It may call
+  models or fetch \u2014 every call is spend per object. Everything entering a
+  mapped source is mapped: jobs, syncs and Source.add() alike.
+
+  The loop: \`inspect\` profiles the objects (key shapes, extensions, sizes,
+  JSON key signatures of ten sampled heads) before a line is written;
+  \`map test --dev\` runs the LOCAL mapper through the running dev session
+  over real objects and prints every outcome without ingesting anything;
+  push a branch and wait for its build (\`releases wait\`) \u2014 a mapper runs on
+  the platform, so the platform has to compile it, and a private branch
+  build is all it needs; \`map deploy\` makes that build's mapper the
+  source's active one (publishing to main activates the mapper main declares
+  too, so merge the branch before publishing); a job or sync runs it; \`jobs
+  quarantine <id>\` lists what it skipped or failed on, by reason; fix, push,
+  \`map deploy\`, \`jobs replay <id>\` runs just those objects again; \`remap\`
+  re-applies a changed mapper to every raw copy the source holds \u2014 no origin
+  traffic, unchanged markdown skipped by hash, changed documents superseding
+  their predecessors. \`jobs start\` refuses (mapper_not_deployed) while the
+  dev session declares a mapper that is not yet active: the job would have
+  loaded the raw records as documents.
+
+  externalId is the identity the platform replaces by: a later object
+  producing the same id supersedes the earlier document; \`replaces\` names
+  ids this document supersedes (a writethru's original); deletes([...])
+  removes by id. A plan on a mapped source records the mapper's outcome mix
+  on its sample; a run whose skip share climbs past twice that (floor 5%)
+  pauses with pauseReason 'skips' for a look at the quarantine.
+`;
 
 // src/commands/dataSources.ts
-var DEFAULT_SOURCE = "default";
-var POLL_MS3 = 3e3;
 var INGEST_FLAGS = {
   chunking: { type: "string" },
   "max-chars": { type: "number", min: 200 },
@@ -3237,8 +4993,16 @@ var dataSourcesSpecs = {
     flags: { source: { type: "string" } }
   },
   "datasources rm": {
-    usage: "Usage: remy-admin datasources rm [--source <slug>] --document <id>",
-    flags: { source: { type: "string" }, document: { type: "string" } }
+    usage: "Usage: remy-admin datasources rm [--source <slug>] (--document <id> | --filter <k=v,...|json>)",
+    flags: {
+      source: { type: "string" },
+      document: { type: "string" },
+      filter: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["document", "filter"],
+      message: "Say what to remove: --document <id> for one document, or --filter <k=v,...|json> for every document that matches."
+    }
   },
   "datasources search": {
     usage: "Usage: remy-admin datasources search [--source <slug>] [--top-k <n>] [--mode <hybrid|semantic|lexical>] [--filter <k=v,...|json>] [--phrase <text>] [--contains <words>] [--max-per-document <n>] [--rerank <true|false>] [--hybrid <true|false>] [--highlight] [--candidate] <query>",
@@ -3311,21 +5075,20 @@ var dataSourcesSpecs = {
     flags: { source: { type: "string" } }
   }
 };
-var sourceOf = (a) => a.str("source") || DEFAULT_SOURCE;
 async function dataSourcesAdd(ctx, a) {
   const files = a.rest("file");
   const slug = sourceOf(a);
   const metadata = parseKeyValuePairs(a.str("metadata"), "metadata");
   const results = [];
   for (const file of files) {
-    const abs = path3.isAbsolute(file) ? file : path3.join(WORKSPACE_DIR, file);
+    const abs = path5.isAbsolute(file) ? file : path5.join(WORKSPACE_DIR, file);
     let bytes;
     try {
-      bytes = fs3.readFileSync(abs);
+      bytes = fs5.readFileSync(abs);
     } catch (err) {
       fatal(`Could not read file "${file}": ${err.message}`);
     }
-    const filename = path3.basename(file);
+    const filename = path5.basename(file);
     results.push(
       await addDocument(ctx, {
         slug,
@@ -3341,32 +5104,24 @@ async function dataSourcesAdd(ctx, a) {
     const timeoutMs = timeoutSec ? timeoutSec * 1e3 : DEFAULT_WAIT_TIMEOUT_MS;
     const result = await waitForIngest(ctx, {
       slug,
-      documentIds: results.filter((r) => !r.skipped).map((r) => r.document.id),
+      // Every document the files became: a mapped source can make several
+      // from one file, or none (a deletes outcome).
+      documentIds: results.filter((r) => !r.skipped).flatMap((r) => r.documents.map((d) => d.id)),
       timeoutMs,
       onProgress: progress
     });
-    if (result.status === "timeout") {
-      out({
-        dataSource: slug,
-        status: result.status,
-        error: result.error,
-        documents: result.documents
-      });
-      process.exit(EXIT.timeout);
-    }
-    if (result.status === "error") {
-      out({
-        dataSource: slug,
-        status: result.status,
-        documents: result.documents
-      });
-      process.exit(EXIT.buildFailed);
-    }
     out({
       dataSource: slug,
       status: result.status,
+      ...result.error ? { error: result.error } : {},
       documents: result.documents
     });
+    if (result.status === "timeout") {
+      throw new CliError(result.error ?? "Timed out.", EXIT.timeout);
+    }
+    if (result.status === "error") {
+      throw new CliError("At least one document failed.", EXIT.buildFailed);
+    }
     return;
   }
   out({ dataSource: slug, documents: results });
@@ -3384,11 +5139,32 @@ async function dataSourcesStatus(ctx, a) {
 }
 async function dataSourcesRm(ctx, a) {
   const documentId = a.str("document");
-  if (!documentId) {
-    fatal("--document is required.");
+  const rawFilter = a.str("filter");
+  if (documentId && rawFilter) {
+    fatal("Give --document or --filter, not both.");
+  }
+  if (documentId) {
+    await rm(ctx, { slug: sourceOf(a), documentId });
+    out({ deleted: documentId });
+    return;
+  }
+  let filter;
+  if (rawFilter.trimStart().startsWith("{")) {
+    try {
+      filter = JSON.parse(rawFilter);
+    } catch (err) {
+      fatal(`--filter is not valid JSON: ${err.message}`);
+    }
+  } else {
+    filter = { metadata: parseKeyValuePairs(rawFilter, "filter") };
   }
-  await rm(ctx, { slug: sourceOf(a), documentId });
-  out({ deleted: documentId });
+  const slug = sourceOf(a);
+  const result = await rmWhereAll(ctx, {
+    slug,
+    filter,
+    onProgress: progress
+  });
+  out({ dataSource: slug, filter, ...result });
 }
 async function dataSourcesDelete(ctx, a) {
   const slug = a.str("source");
@@ -3403,8 +5179,8 @@ async function dataSourcesDelete(ctx, a) {
 async function dataSourcesSearch(ctx, a) {
   const topK = a.num("top-k");
   const retrieval = {
-    ...triState(a, "rerank", "rerank"),
-    ...triState(a, "hybrid", "hybrid")
+    ...triState2(a, "rerank", "rerank"),
+    ...triState2(a, "hybrid", "hybrid")
   };
   const mode = a.str("mode");
   if (mode && !["hybrid", "semantic", "lexical"].includes(mode)) {
@@ -3476,7 +5252,7 @@ function parseKeyValuePairs(raw, flag) {
   }
   return pairs2;
 }
-function triState(a, flag, key) {
+function triState2(a, flag, key) {
   const raw = a.str(flag);
   if (raw === void 0) {
     return {};
@@ -3508,11 +5284,11 @@ function configFromFlags(a) {
     chunking.dropBlockTypes = dropBlocks.split(",").map((s) => s.trim()).filter(Boolean);
   }
   const contextual = {
-    ...triState(a, "contextual", "enabled"),
+    ...triState2(a, "contextual", "enabled"),
     ...a.str("contextual-model") ? { modelId: a.str("contextual-model") } : {}
   };
   const images = {
-    ...triState(a, "describe-images", "describe"),
+    ...triState2(a, "describe-images", "describe"),
     ...a.str("image-model") ? { modelId: a.str("image-model") } : {}
   };
   const embeddingModel = a.str("embedding-model");
@@ -3538,10 +5314,10 @@ function configFromFlags(a) {
     ingest.extraction = { modelId: extractionModel };
   }
   const retrieval = {
-    ...triState(a, "hybrid", "hybrid")
+    ...triState2(a, "hybrid", "hybrid")
   };
   const rerank = {
-    ...triState(a, "rerank", "enabled"),
+    ...triState2(a, "rerank", "enabled"),
     ...a.str("rerank-model") ? { modelId: a.str("rerank-model") } : {}
   };
   if (Object.keys(rerank).length) {
@@ -3623,10 +5399,10 @@ async function dataSourcesMove(ctx, a) {
     ..."error" in result ? { error: result.error } : {}
   });
   if (result.status === "failed") {
-    process.exit(EXIT.buildFailed);
+    throw new CliError(result.error, EXIT.buildFailed);
   }
   if (result.status === "timeout") {
-    process.exit(EXIT.timeout);
+    throw new CliError(result.error, EXIT.timeout);
   }
 }
 async function dataSourcesRevectorize(ctx, a) {
@@ -3641,42 +5417,24 @@ async function dataSourcesRevectorize(ctx, a) {
     return;
   }
   const timeoutSec = a.num("timeout");
-  const timeoutMs = timeoutSec ? timeoutSec * 1e3 : DEFAULT_WAIT_TIMEOUT_MS;
-  const start = Date.now();
-  for (; ; ) {
-    const documents2 = await allDocuments(ctx, {
-      slug,
-      candidate: true
-    });
-    const pending = documents2.filter((d) => d.status === "processing");
-    const failed = documents2.filter((d) => d.status === "error");
-    if (pending.length === 0) {
-      out({
-        dataSource: slug,
-        candidateVersion: started.candidateVersion,
-        status: failed.length ? "error" : "ready",
-        documents: (documents2 ?? []).map(summarize),
-        note: failed.length ? "Some documents failed. Promote with --force to accept, or fix and re-run." : "Run `promote` to make this version live."
-      });
-      if (failed.length) {
-        process.exit(EXIT.buildFailed);
-      }
-      return;
-    }
-    if (Date.now() - start > timeoutMs) {
-      out({
-        dataSource: slug,
-        status: "timeout",
-        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s with ${pending.length} document(s) still building`
-      });
-      process.exit(EXIT.timeout);
-    }
-    progress(
-      `rebuilding\u2026 ${documents2.length - pending.length}/${documents2.length} done (${Math.round(
-        (Date.now() - start) / 1e3
-      )}s)`
-    );
-    await sleep(POLL_MS3);
+  const result = await waitForCandidate(ctx, {
+    slug,
+    ...timeoutSec ? { timeoutMs: timeoutSec * 1e3 } : {},
+    onProgress: progress
+  });
+  if (result.status === "timeout") {
+    out({ dataSource: slug, status: "timeout", error: result.error });
+    throw new CliError(result.error ?? "Timed out.", EXIT.timeout);
+  }
+  out({
+    dataSource: slug,
+    candidateVersion: started.candidateVersion,
+    status: result.status,
+    documents: result.documents,
+    note: result.status === "error" ? "Some documents failed. Promote with --force to accept, or fix and re-run." : "Run `promote` to make this version live."
+  });
+  if (result.status === "error") {
+    throw new CliError("At least one document failed.", EXIT.buildFailed);
   }
 }
 async function dataSourcesPromote(ctx, a) {
@@ -3719,11 +5477,23 @@ Subcommands:
   add          Add one or more documents (skips unchanged files)
   list         List data sources with document counts
   status       Show per-document ingest state
-  rm           Remove a document and its vectors
+  rm           Remove a document, or every document matching a filter
   search       Query a corpus \u2014 useful to sanity-check one you just built
   create       Create an empty source, optionally on dedicated capacity
   config       Show or change how a corpus is processed and searched
   move         Move a corpus between shared and dedicated capacity, data intact
+  jobs         Bulk-load a corpus from a file store or a manifest, with a plan first
+  connect      Follow an S3 bucket the customer owns (credentials = app secret names)
+  sync         Bring a connected source up to date with its bucket
+  connector    Show a source's connector and what it tracks
+  disconnect   Stop following the bucket; documents stay
+  inspect      Profile raw objects (key shapes, types, sizes, JSON keys) before writing a mapper
+  map test     Run a source's mapper over real objects and show the outcomes; nothing ingested
+  map deploy   Make a build's compiled mapper the source's active one (a branch build will do)
+  remap        Re-apply the active mapper to every raw copy the source holds
+  hydrate      Reload an evicted index ahead of the first search
+  sample       Draw a sample of a source into a new one with the same config
+  eval         Query sets and runs: measure recall, MRR and latency, compare versions
   revectorize  Rebuild a corpus under new settings, alongside the live one
   promote      Make a rebuilt version live
   drop         Discard a candidate or a superseded version
@@ -3733,11 +5503,15 @@ Usage:
   remy-admin datasources add [--source <slug>] [--metadata <k=v,...>] [--wait] [--timeout <sec>] <file...>
   remy-admin datasources list
   remy-admin datasources status [--source <slug>]
-  remy-admin datasources rm [--source <slug>] --document <id>
+  remy-admin datasources rm [--source <slug>] (--document <id> | --filter <k=v,...|json>)
   remy-admin datasources search [--source <slug>] [search options] <query>
   remy-admin datasources create --source <slug> [--name <name>] [--placement <resource-id|shared>] [rebuild settings...]
   remy-admin datasources config [--source <slug>] [--placement <resource-id|shared>] [settings...]
   remy-admin datasources move [--source <slug>] --to <resource-id|shared> [--wait] [--timeout <sec>]
+  remy-admin datasources jobs start|list|status|approve|pause|resume|cancel \u2026 (see below)
+  remy-admin datasources connect|sync|connector|disconnect \u2026 (see below)
+  remy-admin datasources hydrate|sample \u2026 (see below)
+  remy-admin datasources eval create|list|get|add|import|queries|rm|delete|run|runs|result|compare \u2026 (see below)
   remy-admin datasources revectorize [--source <slug>] [settings...] [--wait]
   remy-admin datasources promote [--source <slug>] [--force]
   remy-admin datasources drop [--source <slug>] [--version <n>]
@@ -3830,6 +5604,11 @@ Notes:
   Re-adding an unchanged file is free: no upload, no re-embedding. Re-adding
     with a different --metadata updates the tags in place, also free.
   --metadata tags documents for search-time filtering (scalars, \u226416 keys).
+  rm --filter removes every matching document in pages of a thousand: k=v
+    pairs match metadata; a JSON object takes the full selector \u2014 metadata,
+    filename, documentIds, externalIdPrefix (the key a job or connector
+    recorded, e.g. '{"externalIdPrefix":"archive/2019/"}'). An empty filter
+    is refused; to remove everything, delete the source.
   delete requires an explicit --source (no default) and refuses while documents
     are still ingesting. Extraction caches survive deletion, so re-ingesting
     the same files elsewhere costs no re-extraction.
@@ -3847,7 +5626,24 @@ Examples:
   remy-admin datasources revectorize --source policies --max-chars 900 --wait
   remy-admin datasources search --source policies --candidate "payment terms"
   remy-admin datasources promote --source policies
-`;
+
+  # Load a whole corpus: plan first, approve, watch it run
+  remy-admin datasources jobs start --source archive --store raw --prefix 2024/ --wait
+  remy-admin datasources jobs approve <id> --wait
+
+  # Follow a customer's bucket: secrets by name, first sync stops for approval
+  remy-admin secrets set ARCHIVE_S3_KEY --prod <value>      # never on a command line you share
+  remy-admin datasources connect --source archive --bucket acme-docs --region us-east-1 --prefix contracts/ --access-key-secret ARCHIVE_S3_KEY --secret-key-secret ARCHIVE_S3_SECRET --budget-per-sync 5
+  remy-admin datasources sync --source archive --wait
+
+  # Measure before you promote: sample, build a query set, run live vs candidate
+  remy-admin datasources sample --source archive --size 300 --wait
+  remy-admin datasources eval create --source archive-sample --name base --size 150 --wait
+  remy-admin datasources eval run --set <setId> --label live --wait
+  remy-admin datasources revectorize --source archive-sample --max-chars 900 --wait
+  remy-admin datasources eval run --set <setId> --candidate --label small-chunks --wait
+  remy-admin datasources eval compare <runA> <runB>
+${dataSourceJobsHelp}${dataSourceConnectorsHelp}${dataSourceMappersHelp}${dataSourceEvalsHelp}`;
 
 // src/ops/voice.ts
 function normalizeE164(input) {
@@ -4422,7 +6218,7 @@ function runs(ctx, params = {}) {
     `/_internal/v2/apps/${ctx.appId}/jewels/training-runs${qs(params)}`
   );
 }
-function getRun(ctx, runId) {
+function getRun2(ctx, runId) {
   return call(
     ctx,
     "GET",
@@ -4582,9 +6378,9 @@ async function jewelsTimeseries(ctx, a) {
   );
 }
 async function jewelsResolve(ctx, a) {
-  const approve = a.bool("approve");
+  const approve2 = a.bool("approve");
   const dismiss = a.bool("dismiss");
-  if (approve === dismiss) {
+  if (approve2 === dismiss) {
     fatal("Pass exactly one of --approve or --dismiss.");
   }
   if (dismiss && a.str("input") !== void 0) {
@@ -4592,7 +6388,7 @@ async function jewelsResolve(ctx, a) {
   }
   const params = {
     itemId: a.req("itemId"),
-    action: approve ? "approve" : "dismiss"
+    action: approve2 ? "approve" : "dismiss"
   };
   if (a.str("input") !== void 0) {
     params.input = parseJsonFlag(a, "input");
@@ -4640,28 +6436,28 @@ async function jewelsTrain(ctx, a) {
   let lastLogLen = 0;
   while (Date.now() < deadline) {
     await sleep(TRAIN_POLL_MS);
-    const { run: run2 } = await getRun(ctx, runId);
-    const log = Array.isArray(run2.log) ? run2.log : [];
+    const { run: run3 } = await getRun2(ctx, runId);
+    const log = Array.isArray(run3.log) ? run3.log : [];
     const fresh = log.slice(lastLogLen);
     lastLogLen = log.length;
     const isStatus = (x) => x?.kind === "status";
     const isLoss = (x) => x?.kind === "loss";
     for (const e of fresh.filter(isStatus)) {
-      out({ status: run2.status, at: e.ts, message: e.message });
+      out({ status: run3.status, at: e.ts, message: e.message });
     }
     const losses = fresh.filter(isLoss);
     if (losses.length) {
       const last = losses[losses.length - 1];
-      const p = run2.progress;
+      const p = run3.progress;
       out({
-        status: run2.status,
+        status: run3.status,
         step: `${last.step}/${p?.totalSteps ?? "?"}`,
         loss: last.loss
       });
     }
-    if (run2.status === "complete" || run2.status === "failed") {
-      out(compactRunLog(run2));
-      if (run2.status === "failed") {
+    if (run3.status === "complete" || run3.status === "failed") {
+      out(compactRunLog(run3));
+      if (run3.status === "failed") {
         process.exitCode = 1;
       }
       return;
@@ -4671,19 +6467,19 @@ async function jewelsTrain(ctx, a) {
     `Timed out waiting for run ${runId} (still in flight; check 'jewels run ${runId}').`
   );
 }
-function compactRunLog(run2) {
-  let out2 = { ...run2 };
-  if (Array.isArray(run2.log)) {
-    const statusEntries = run2.log.filter((e) => e?.kind === "status");
-    const lossPoints = run2.log.length - statusEntries.length;
+function compactRunLog(run3) {
+  let out2 = { ...run3 };
+  if (Array.isArray(run3.log)) {
+    const statusEntries = run3.log.filter((e) => e?.kind === "status");
+    const lossPoints = run3.log.length - statusEntries.length;
     out2 = { ...out2, log: { statusEntries, lossPoints } };
   }
-  if (Array.isArray(run2.report?.candidates)) {
+  if (Array.isArray(run3.report?.candidates)) {
     out2 = {
       ...out2,
       report: {
-        ...run2.report,
-        candidates: run2.report.candidates.map(
+        ...run3.report,
+        candidates: run3.report.candidates.map(
           (c) => Array.isArray(c?.predictions) ? { ...c, predictions: c.predictions.length } : c
         )
       }
@@ -4700,8 +6496,8 @@ async function jewelsRuns(ctx, a) {
   );
 }
 async function jewelsRunGet(ctx, a) {
-  const { run: run2 } = await getRun(ctx, a.req("runId"));
-  out({ run: compactRunLog(run2) });
+  const { run: run3 } = await getRun2(ctx, a.req("runId"));
+  out({ run: compactRunLog(run3) });
 }
 async function jewelsGrade(ctx, a) {
   out(await grade(ctx, a.req("runId")));
@@ -5148,14 +6944,14 @@ async function resolveDomainId(ctx, direction, domain) {
   }
   return match.id;
 }
-function list9(ctx, params = {}) {
+function list10(ctx, params = {}) {
   return call(
     ctx,
     "GET",
     `/_internal/v2/apps/${ctx.appId}/outbound-email/messages${qs(params)}`
   );
 }
-function get7(ctx, messageId) {
+function get9(ctx, messageId) {
   return call(
     ctx,
     "GET",
@@ -5347,7 +7143,7 @@ var emailSpecs = {
 };
 async function emailList(ctx, a) {
   out(
-    await list9(ctx, {
+    await list10(ctx, {
       status: a.str("status"),
       kind: a.str("kind"),
       recipient: a.str("recipient"),
@@ -5361,7 +7157,7 @@ async function emailList(ctx, a) {
   );
 }
 async function emailGet(ctx, a) {
-  out(await get7(ctx, a.req("messageId")));
+  out(await get9(ctx, a.req("messageId")));
 }
 async function emailStats(ctx, a) {
   out(await stats2(ctx, { start: a.str("start"), end: a.str("end") }));
@@ -5537,14 +7333,14 @@ Examples:
 `;
 
 // src/ops/cron.ts
-function list10(ctx, params = {}) {
+function list11(ctx, params = {}) {
   return call(
     ctx,
     "GET",
     `/_internal/v2/apps/${ctx.appId}/cron/overview${qs(params)}`
   );
 }
-function run(ctx, route) {
+function run2(ctx, route) {
   return call(
     ctx,
     "POST",
@@ -5566,10 +7362,10 @@ var cronSpecs = {
   }
 };
 async function cronList(ctx, a) {
-  out(await list10(ctx, { runs: a.num("runs") }));
+  out(await list11(ctx, { runs: a.num("runs") }));
 }
 async function cronRun(ctx, a) {
-  out(await run(ctx, a.req("route")));
+  out(await run2(ctx, a.req("route")));
 }
 var cronHandlers = {
   "cron list": cronList,
@@ -5600,27 +7396,27 @@ Examples:
   remy-admin cron run dailyDigest`;
 
 // src/ops/infra.ts
-var DEFAULT_WAIT_TIMEOUT_MS2 = 10 * 60 * 1e3;
-var POLL_MS4 = 3e3;
-function base2(appId) {
+var DEFAULT_WAIT_TIMEOUT_MS4 = 10 * 60 * 1e3;
+var POLL_MS5 = 3e3;
+function base6(appId) {
   return `/_internal/v2/apps/${appId}/infra`;
 }
-function list11(ctx, params) {
+function list12(ctx, params) {
   return call(
     ctx,
     "GET",
-    `${base2(ctx.appId)}${params?.includeDestroyed ? "?includeDestroyed=true" : ""}`
+    `${base6(ctx.appId)}${params?.includeDestroyed ? "?includeDestroyed=true" : ""}`
   );
 }
-function get8(ctx, params) {
+function get10(ctx, params) {
   return call(
     ctx,
     "GET",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}`
   );
 }
 function provision(ctx, params) {
-  return call(ctx, "POST", base2(ctx.appId), {
+  return call(ctx, "POST", base6(ctx.appId), {
     offeringId: params.offeringId,
     ...params.name ? { name: params.name } : {}
   });
@@ -5629,28 +7425,28 @@ function hibernate(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/hibernate`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/hibernate`
   );
 }
-function resume(ctx, params) {
+function resume2(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/resume`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/resume`
   );
 }
 function destroy(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/destroy`
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/destroy`
   );
 }
 function resize(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/resize`,
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/resize`,
     { offeringId: params.offeringId }
   );
 }
@@ -5658,56 +7454,40 @@ function rename(ctx, params) {
   return call(
     ctx,
     "POST",
-    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/rename`,
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/rename`,
     { name: params.name }
   );
 }
 async function waitForPhase(ctx, params) {
-  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS2;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS4;
   const wanted = new Set(params.phases);
-  const start = Date.now();
-  let transientSince = null;
-  for (; ; ) {
-    let resource;
-    try {
-      ({ resource } = await get8(ctx, { id: params.id }));
-      transientSince = null;
-    } catch (err) {
-      if (!isTransientError(err)) {
-        throw err;
-      }
-      transientSince ??= Date.now();
-      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
-        throw err;
-      }
-      params.onProgress?.(
-        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
-      );
-      await sleep(POLL_MS4);
-      continue;
-    }
-    if (wanted.has(resource.phase) && (params.until?.(resource) ?? true)) {
-      return { status: "done", resource };
-    }
-    if (resource.phase === "failed") {
-      return {
-        status: "failed",
-        resource,
-        error: resource.lastError ?? "The platform could not complete the change."
-      };
-    }
-    if (Date.now() - start > timeoutMs) {
-      return {
-        status: "timeout",
-        resource,
-        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s; resource is still ${resource.phase}`
-      };
+  const arrived = (resource2) => wanted.has(resource2.phase) && (params.until?.(resource2) ?? true);
+  const outcome = await pollUntil(
+    async () => (await get10(ctx, { id: params.id })).resource,
+    (resource2) => arrived(resource2) || resource2.phase === "failed",
+    {
+      timeoutMs,
+      pollMs: POLL_MS5,
+      describe: (resource2, start2) => `${resource2.phase}${resource2.detail ? ` \xB7 ${resource2.detail}` : ""}${resource2.resizingTo ? ` \xB7 resizing to ${resource2.resizingTo.label}` : ""}\u2026 (${elapsedSeconds(start2)}s)`,
+      onProgress: params.onProgress
     }
-    params.onProgress?.(
-      `${resource.phase}${resource.detail ? ` \xB7 ${resource.detail}` : ""}${resource.resizingTo ? ` \xB7 resizing to ${resource.resizingTo.label}` : ""}\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
-    );
-    await sleep(POLL_MS4);
+  );
+  const resource = outcome.value;
+  if (!outcome.settled) {
+    return {
+      status: "timeout",
+      resource,
+      error: timedOut(timeoutMs, `; resource is still ${resource.phase}`)
+    };
   }
+  if (arrived(resource)) {
+    return { status: "done", resource };
+  }
+  return {
+    status: "failed",
+    resource,
+    error: resource.lastError ?? "The platform could not complete the change."
+  };
 }
 
 // src/commands/infra.ts
@@ -5768,7 +7548,7 @@ var infraSpecs = {
     }
   }
 };
-async function waitAndReport(ctx, a, id, phases, summary2, until) {
+async function waitAndReport2(ctx, a, id, phases, summary2, until) {
   const timeoutSec = a.str("timeout");
   const result = await waitForPhase(ctx, {
     id,
@@ -5786,10 +7566,10 @@ async function waitAndReport(ctx, a, id, phases, summary2, until) {
   }
 }
 async function infraList(ctx, a) {
-  out(await list11(ctx, { includeDestroyed: a.bool("include-destroyed") }));
+  out(await list12(ctx, { includeDestroyed: a.bool("include-destroyed") }));
 }
 async function infraGet(ctx, a) {
-  out(await get8(ctx, { id: a.req("id") }));
+  out(await get10(ctx, { id: a.req("id") }));
 }
 function pricingOf(resource) {
   const offering = resource.offering;
@@ -5819,7 +7599,7 @@ async function infraProvision(ctx, a) {
     });
     return;
   }
-  await waitAndReport(ctx, a, resource.id, ["active"], {
+  await waitAndReport2(ctx, a, resource.id, ["active"], {
     action: "provision",
     pricing
   });
@@ -5831,16 +7611,16 @@ async function infraHibernate(ctx, a) {
     out({ resource });
     return;
   }
-  await waitAndReport(ctx, a, id, ["hibernated"], { action: "hibernate" });
+  await waitAndReport2(ctx, a, id, ["hibernated"], { action: "hibernate" });
 }
 async function infraResume(ctx, a) {
   const id = a.req("id");
-  const { resource } = await resume(ctx, { id });
+  const { resource } = await resume2(ctx, { id });
   if (!a.bool("wait")) {
     out({ resource });
     return;
   }
-  await waitAndReport(ctx, a, id, ["active"], { action: "resume" });
+  await waitAndReport2(ctx, a, id, ["active"], { action: "resume" });
 }
 async function infraDestroy(ctx, a) {
   const id = a.req("id");
@@ -5849,7 +7629,7 @@ async function infraDestroy(ctx, a) {
     out({ resource });
     return;
   }
-  await waitAndReport(ctx, a, id, ["destroyed"], { action: "destroy" });
+  await waitAndReport2(ctx, a, id, ["destroyed"], { action: "destroy" });
 }
 async function infraRename(ctx, a) {
   out(
@@ -5877,7 +7657,7 @@ async function infraResize(ctx, a) {
     });
     return;
   }
-  await waitAndReport(
+  await waitAndReport2(
     ctx,
     a,
     id,
@@ -5983,6 +7763,10 @@ var SPECS = {
   ...prerenderSpecs,
   ...filesSpecs,
   ...dataSourcesSpecs,
+  ...dataSourceJobsSpecs,
+  ...dataSourceConnectorsSpecs,
+  ...dataSourceEvalsSpecs,
+  ...dataSourceMappersSpecs,
   ...voiceSpecs,
   ...agentSpecs,
   ...eventsSpecs,
@@ -6008,6 +7792,10 @@ var HANDLERS = {
   ...prerenderHandlers,
   ...filesHandlers,
   ...dataSourcesHandlers,
+  ...dataSourceJobsHandlers,
+  ...dataSourceConnectorsHandlers,
+  ...dataSourceEvalsHandlers,
+  ...dataSourceMappersHandlers,
   ...voiceHandlers,
   ...agentHandlers,
   ...eventsHandlers,
@@ -6044,8 +7832,8 @@ var GROUP_HELP = {
 };
 
 // src/ctx.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path6 from "path";
 
 // src/parseJsonConfig.ts
 import JSON5 from "json5";
@@ -6074,10 +7862,10 @@ function parseJsonConfig(raw) {
 // src/ctx.ts
 var DEFAULT_BASE_URL = "https://api.mindstudio.ai";
 function loadWorkspaceAppId(workspaceDir = WORKSPACE_DIR) {
-  const manifestPath = path4.join(workspaceDir, "mindstudio.json");
+  const manifestPath = path6.join(workspaceDir, "mindstudio.json");
   let raw;
   try {
-    raw = fs4.readFileSync(manifestPath, "utf-8");
+    raw = fs6.readFileSync(manifestPath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       throw new Error(`mindstudio.json not found at ${manifestPath}`);
@@ -6181,6 +7969,11 @@ function resolveRoute(argv) {
       error: `Unknown subcommand: settings ${sub} ${action ?? ""}. Run 'remy-admin settings --help'`
     };
   }
+  if (group === "datasources" && (sub === "jobs" || sub === "eval" || sub === "map")) {
+    return {
+      error: `Unknown subcommand: datasources ${sub} ${action ?? ""}. Run 'remy-admin datasources --help'`
+    };
+  }
   if (group === "email" && ["domains", "inbound-domains"].includes(sub ?? "")) {
     return {
       error: `Unknown subcommand: email ${sub} ${action ?? ""}. Run 'remy-admin email --help'`