@sleds/cli 0.1.64 → 0.1.66

package/dist/sleds.mjs

@@ -6061,7 +6061,6 @@ var init_adf = __esm(() => {
     "decisionList"
   ]);
 });
-
 // ../../packages/shared/src/help/whatsNew.ts
 var SEPT_30 = "/whats-new/2026-09-30", WHATS_NEW;
 var init_whatsNew = __esm(() => {
@@ -6836,6 +6835,30 @@ var init_stability = __esm(() => {
   init_series();
 });
 
+// ../../packages/shared/src/deploys/shipping.ts
+var DAY_MS5;
+var init_shipping = __esm(() => {
+  DAY_MS5 = 24 * 60 * 60 * 1000;
+});
+
+// ../../packages/shared/src/deploys/doraBands.ts
+var HOUR_MS2, DAY_MS6, WEEK_MS3, MONTH_DAYS = 30, MONTH_MS;
+var init_doraBands = __esm(() => {
+  HOUR_MS2 = 60 * 60 * 1000;
+  DAY_MS6 = 24 * HOUR_MS2;
+  WEEK_MS3 = 7 * DAY_MS6;
+  MONTH_MS = MONTH_DAYS * DAY_MS6;
+});
+
+// ../../packages/shared/src/deploys/trends.ts
+var DAY_MS7;
+var init_trends = __esm(() => {
+  init_batchSize();
+  init_metrics();
+  init_series();
+  DAY_MS7 = 24 * 60 * 60 * 1000;
+});
+
 // ../../packages/shared/src/newrelic/newrelic.ts
 var init_newrelic = () => {};
 
@@ -8353,6 +8376,9 @@ var init_src = __esm(() => {
   init_batchSize();
   init_report();
   init_series();
+  init_shipping();
+  init_doraBands();
+  init_trends();
   init_sentry();
   init_newrelic();
   init_musher();
@@ -9071,8 +9097,8 @@ var init_seat = __esm(() => {
 });
 
 // src/index.ts
-import { existsSync as existsSync36, realpathSync as realpathSync3 } from "fs";
-import { homedir as homedir10, platform as platform3 } from "os";
+import { existsSync as existsSync37, realpathSync as realpathSync3 } from "fs";
+import { homedir as homedir11, platform as platform3 } from "os";
 import { fileURLToPath } from "url";
 
 // ../../packages/shared/src/index.ts
@@ -9124,6 +9150,9 @@ init_stability();
 init_batchSize();
 init_report();
 init_series();
+init_shipping();
+init_doraBands();
+init_trends();
 init_sentry();
 init_newrelic();
 init_musher();
@@ -11793,7 +11822,7 @@ function beatBody(state, flags, host = {}, cap = {}) {
     name: flags.name,
     os: host.os ?? process.platform,
     runner: flags.runner,
-    version: host.version ?? "0.1.64" ?? "dev",
+    version: host.version ?? "0.1.66" ?? "dev",
     running: live.length,
     items: live.slice(0, BEAT_ITEMS).map((r) => `${r.item}/${r.node}`),
     ...cap.atOnce !== undefined ? { atOnce: cap.atOnce } : {},
@@ -18611,7 +18640,7 @@ async function fetchVersion(o) {
   const platform = o.platform ?? process.platform;
   const arch = o.arch ?? process.arch;
   const publicKey = o.publicKey ?? RELEASE_PUBLIC_KEY;
-  const running = o.running ?? "0.1.64";
+  const running = o.running ?? "0.1.66";
   if (!publicKey)
     return { ok: false, why: "no release key yet" };
   if (!VERSION_RE2.test(o.version))
@@ -19837,7 +19866,7 @@ function engineUpdater(o) {
 
 // src/version.ts
 function cliVersion(env) {
-  return "0.1.64";
+  return "0.1.66";
 }
 
 // src/commands/update.ts
@@ -20223,7 +20252,7 @@ function engineClient(o, org, breaker) {
       ...src,
       ...breaker ? { fetchFn: breaker.fetch } : {},
       timeoutMs: ENGINE_TIMEOUT_MS,
-      version: "0.1.64"
+      version: "0.1.66"
     });
   const asked = org?.trim() || env.SLEDS_ORG?.trim();
   if (asked && !selectOrg(readConfig(o.home), org, env).seat)
@@ -20529,7 +20558,7 @@ async function driveEngine(o, flags, deps, until = {}) {
     runner: deps.runner.name,
     atOnce: flags.atOnce,
     interval: flags.interval,
-    cliVersion: "0.1.64"
+    cliVersion: "0.1.66"
   };
   const beat = (checkedAt) => {
     const m = deps.machine;
@@ -22398,7 +22427,7 @@ function engineClient2(o, org, breaker) {
       ...src,
       ...breaker ? { fetchFn: breaker.fetch } : {},
       timeoutMs: ENGINE_TIMEOUT_MS2,
-      version: "0.1.64"
+      version: "0.1.66"
     });
   const asked = org?.trim() || env.SLEDS_ORG?.trim();
   if (asked && !selectOrg(readConfig(o.home), org, env).seat)
@@ -22739,7 +22768,7 @@ async function driveEngine2(o, flags, deps, until = {}) {
     runner: deps.runner.name,
     atOnce: flags.atOnce,
     interval: flags.interval,
-    cliVersion: "0.1.64"
+    cliVersion: "0.1.66"
   };
   const beat = (checkedAt) => {
     const m = deps.machine;
@@ -24850,7 +24879,7 @@ function contextFor(deps) {
     ...src,
     fetchFn: deps.fetchFn,
     timeoutMs: deps.timeoutMs,
-    version: "0.1.64"
+    version: "0.1.66"
   }), deps.home, now) : null;
   return {
     channel: "code",
@@ -28367,9 +28396,1098 @@ var sessionEvent = async (o) => {
   return 0;
 };
 
+// src/commands/sleuth.ts
+import { homedir as homedir8 } from "node:os";
+import { join as join35, resolve as resolve12 } from "node:path";
+
+// src/sleuth/export.ts
+import { existsSync as existsSync31, mkdirSync as mkdirSync28, readFileSync as readFileSync32, renameSync as renameSync13, writeFileSync as writeFileSync28 } from "node:fs";
+import { dirname as dirname25, join as join34 } from "node:path";
+
+// src/sleuth/graphql.ts
+var SLEUTH_URL = "https://app.sleuth.io/graphql";
+
+class SleuthError extends Error {
+  adaptable;
+  constructor(message, adaptable) {
+    super(message);
+    this.adaptable = adaptable;
+  }
+}
+var RATE = /rate.?limit|throttl|too many requests/i;
+var backoffMs = (attempt, retryAfter) => {
+  const s = Number(retryAfter);
+  if (retryAfter && Number.isFinite(s) && s >= 0)
+    return Math.min(s, 300) * 1000;
+  return Math.min(60000, 1000 * 2 ** attempt);
+};
+var sleuthClient = (o) => {
+  const url = o.url ?? SLEUTH_URL;
+  const fetchFn = o.fetch ?? ((u, init) => fetch(u, init));
+  const sleep = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const retries = o.retries ?? 6;
+  const timeoutMs = o.timeoutMs ?? 120000;
+  let scheme = "apikey";
+  let settled = false;
+  let count = 0;
+  const request = async (query) => {
+    let lastWhy = "";
+    for (let attempt = 0;attempt <= retries; attempt++) {
+      let res;
+      count++;
+      try {
+        res = await fetchFn(url, {
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: `${scheme} ${o.key}` },
+          body: JSON.stringify({ query }),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+      } catch (e) {
+        lastWhy = e instanceof Error ? e.message : String(e);
+        o.log?.(`sleuth: ${lastWhy} — retrying`);
+        await sleep(backoffMs(attempt, null));
+        continue;
+      }
+      if ((res.status === 401 || res.status === 403) && !settled) {
+        settled = true;
+        scheme = "Bearer";
+        attempt--;
+        continue;
+      }
+      if (res.status === 401 || res.status === 403)
+        throw new SleuthError(`Sleuth refused the key (HTTP ${res.status}) — check SLEUTH_API_KEY`, false);
+      if (res.status === 429 || res.status >= 500) {
+        lastWhy = `HTTP ${res.status}`;
+        const wait = backoffMs(attempt, res.headers.get("retry-after"));
+        o.log?.(`sleuth: ${lastWhy} — waiting ${Math.round(wait / 1000)}s`);
+        await sleep(wait);
+        continue;
+      }
+      const text = await res.text();
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        throw new SleuthError(`Sleuth answered HTTP ${res.status} with no JSON`, res.status < 500);
+      }
+      const errors = Array.isArray(body.errors) ? body.errors : [];
+      if (res.status >= 400 && !errors.length)
+        throw new SleuthError(`Sleuth answered HTTP ${res.status}`, false);
+      settled = true;
+      if (!body.data && errors.some((e) => RATE.test(e.message))) {
+        lastWhy = errors[0]?.message ?? "rate limited";
+        await sleep(backoffMs(attempt, null));
+        continue;
+      }
+      return { data: body.data ?? null, errors };
+    }
+    throw new SleuthError(`Sleuth did not answer after ${retries + 1} tries (${lastWhy})`, true);
+  };
+  return { request, calls: () => count };
+};
+
+// src/sleuth/schema.ts
+var MAX_QUERY_DEPTH = 10;
+var TYPE_REF = "kind name ofType { kind name ofType { kind name ofType { kind name } } }";
+var INTROSPECTION_QUERY = `query SledsSleuthIntrospection { __schema { queryType { name } types { kind name fields(includeDeprecated: false) { name args { name defaultValue type { ${TYPE_REF} } } type { ${TYPE_REF} } } inputFields { name defaultValue type { ${TYPE_REF} } } } } }`;
+var queryDepth = (query) => {
+  let braces = 0;
+  let parens = 0;
+  let inString = false;
+  let max = 0;
+  for (let i = 0;i < query.length; i++) {
+    const c = query[i];
+    if (inString) {
+      if (c === "\\")
+        i++;
+      else if (c === '"')
+        inString = false;
+    } else if (c === '"')
+      inString = true;
+    else if (c === "(")
+      parens++;
+    else if (c === ")")
+      parens--;
+    else if (parens > 0)
+      continue;
+    else if (c === "{")
+      braces++;
+    else if (c === "}")
+      braces--;
+    else if (braces > max && /[A-Za-z_]/.test(c))
+      max = braces;
+  }
+  return max;
+};
+var indexSchema = (intro) => ({
+  query: intro.__schema.queryType.name,
+  types: new Map(intro.__schema.types.map((t) => [t.name, t]))
+});
+var unwrap = (t) => {
+  let cur = t;
+  let list = false;
+  const required = t.kind === "NON_NULL";
+  while (cur && (cur.kind === "NON_NULL" || cur.kind === "LIST")) {
+    if (cur.kind === "LIST")
+      list = true;
+    cur = cur.ofType;
+  }
+  return { name: cur?.name ?? "", list, required };
+};
+var kindOf = (s, name) => s.types.get(name)?.kind ?? "";
+var isLeaf = (s, name) => ["SCALAR", "ENUM"].includes(kindOf(s, name));
+var isComposite = (s, name) => ["OBJECT", "INTERFACE"].includes(kindOf(s, name));
+var isRequired = (a) => a.type.kind === "NON_NULL" && (a.defaultValue === null || a.defaultValue === undefined);
+var fieldOf2 = (s, type, name) => s.types.get(type)?.fields?.find((f) => f.name === name);
+var ORG = /^(org|orgSlug|organization|organizationSlug|orgId)$/i;
+var START = /^(start|startDate|startTime|startAt|from|fromDate|dateFrom|since|begin|after)$/i;
+var END = /^(end|endDate|endTime|endAt|to|toDate|dateTo|until|before)$/i;
+var CURSOR = /^(after|cursor|nextCursor|pageCursor|pageToken)$/i;
+var PAGE = /^(page|pageNumber|pageNum)$/i;
+var SIZE = /^(first|pageSize|limit|perPage|per_page|size|count|pageLimit)$/i;
+var OFFSET = /^(offset|skip)$/i;
+var DATEISH = /date|time/i;
+var dateArg = (path, typeName) => ({
+  path,
+  dateOnly: /^date$/i.test(typeName)
+});
+var planArgs = (s, args) => {
+  const plan = { org: [], missing: [] };
+  const visit = (vals, prefix, depth) => {
+    for (const a of vals) {
+      const u = unwrap(a.type);
+      const path = [...prefix, a.name];
+      const leaf = isLeaf(s, u.name);
+      const dated = leaf && (DATEISH.test(u.name) || u.name === "String" && DATEISH.test(a.name) && (START.test(a.name) || END.test(a.name)));
+      if (kindOf(s, u.name) === "INPUT_OBJECT") {
+        const before = JSON.stringify(plan);
+        const inputs = s.types.get(u.name)?.inputFields ?? [];
+        if (depth < 3)
+          visit(inputs, path, depth + 1);
+        if (isRequired(a) && JSON.stringify(plan) === before && inputs.some(isRequired))
+          plan.missing.push(path.join("."));
+        continue;
+      }
+      if (leaf && !u.list && ORG.test(a.name))
+        plan.org.push(path);
+      else if (dated && START.test(a.name) && !plan.start)
+        plan.start = dateArg(path, u.name);
+      else if (dated && END.test(a.name) && !plan.end)
+        plan.end = dateArg(path, u.name);
+      else if (leaf && !dated && CURSOR.test(a.name) && !plan.cursor)
+        plan.cursor = path;
+      else if (leaf && PAGE.test(a.name) && !plan.page)
+        plan.page = { path, first: Number(a.defaultValue ?? 1) || 0 };
+      else if (leaf && SIZE.test(a.name) && !plan.size)
+        plan.size = path;
+      else if (leaf && OFFSET.test(a.name) && !plan.offset)
+        plan.offset = path;
+      else if (isRequired(a))
+        plan.missing.push(path.join("."));
+    }
+  };
+  visit(args, [], 0);
+  return plan;
+};
+var windowed = (p) => !!(p.start && p.end);
+var pageable = (p) => !!(p.cursor || p.page || p.offset);
+var iso3 = (d, dateOnly) => dateOnly ? d.toISOString().slice(0, 10) : d.toISOString().replace(/\.\d{3}Z$/, "Z");
+var gqlValue = (v) => {
+  if (typeof v === "string")
+    return JSON.stringify(v);
+  if (typeof v === "number" || typeof v === "boolean")
+    return String(v);
+  if (Array.isArray(v))
+    return `[${v.map(gqlValue).join(", ")}]`;
+  if (v && typeof v === "object")
+    return `{${Object.entries(v).map(([k, x]) => `${k}: ${gqlValue(x)}`).join(", ")}}`;
+  return "null";
+};
+var renderArgs = (p, v) => {
+  const root = {};
+  const put = (path, value) => {
+    if (!path || value === undefined)
+      return;
+    let o = root;
+    for (const k of path.slice(0, -1)) {
+      if (!o[k])
+        o[k] = {};
+      o = o[k];
+    }
+    o[path[path.length - 1]] = value;
+  };
+  for (const path of p.org)
+    put(path, v.org);
+  if (p.start && v.start)
+    put(p.start.path, iso3(v.start, p.start.dateOnly));
+  if (p.end && v.end)
+    put(p.end.path, iso3(v.end, p.end.dateOnly));
+  put(p.cursor, v.cursor);
+  put(p.page?.path, v.page);
+  put(p.size, v.size);
+  put(p.offset, v.offset);
+  const body = gqlValue(root);
+  return body === "{}" ? "" : `(${body.slice(1, -1)})`;
+};
+var ITEMS = ["objects", "nodes", "items", "results", "edges", "data", "entries", "records"];
+var HAS_NEXT = /^(hasNextPage|hasNext|hasMore|more)$/;
+var NEXT = /^(endCursor|nextCursor|cursor|next|nextPageCursor|nextPage)$/;
+var TOTAL = /^(totalCount|total|count|totalObjects|totalItems)$/;
+var shapeOf = (s, f) => {
+  const u = unwrap(f.type);
+  if (!isComposite(s, u.name))
+    return;
+  if (u.list)
+    return { kind: "list", item: u.name };
+  const t = s.types.get(u.name);
+  const lists = (t?.fields ?? []).filter((x) => {
+    const xu = unwrap(x.type);
+    return xu.list && isComposite(s, xu.name) && !x.args.some(isRequired);
+  });
+  const rank = (n) => ITEMS.includes(n) ? ITEMS.indexOf(n) : ITEMS.length;
+  const itemsField = [...lists].sort((a, b) => rank(a.name) - rank(b.name))[0];
+  const scalars = (t?.fields ?? []).filter((x) => isLeaf(s, unwrap(x.type).name));
+  const info = (t?.fields ?? []).find((x) => /^pageInfo$/i.test(x.name) && isComposite(s, unwrap(x.type).name));
+  const infoScalars = info ? (s.types.get(unwrap(info.type).name)?.fields ?? []).filter((x) => isLeaf(s, unwrap(x.type).name)) : [];
+  const find = (re) => {
+    const own = scalars.find((x) => re.test(x.name));
+    if (own)
+      return [own.name];
+    const inInfo = infoScalars.find((x) => re.test(x.name));
+    return inInfo && info ? [info.name, inInfo.name] : undefined;
+  };
+  const hasNext = find(HAS_NEXT);
+  const next = find(NEXT);
+  const total = find(TOTAL);
+  const looksLikePage = itemsField && (ITEMS.includes(itemsField.name) || hasNext || next || total || info);
+  if (!itemsField || !looksLikePage)
+    return { kind: "object", item: u.name };
+  let item = unwrap(itemsField.type).name;
+  let node;
+  if (itemsField.name === "edges") {
+    const n = fieldOf2(s, item, "node");
+    if (n && isComposite(s, unwrap(n.type).name)) {
+      node = "node";
+      item = unwrap(n.type).name;
+    }
+  }
+  return {
+    kind: "page",
+    item,
+    items: itemsField.name,
+    ...node ? { node } : {},
+    ...hasNext ? { hasNext } : {},
+    ...next ? { next } : {},
+    ...total ? { total } : {}
+  };
+};
+var wrapShape = (shape, inner) => {
+  if (shape.kind !== "page")
+    return inner;
+  const paths = [shape.hasNext, shape.next, shape.total].filter((p) => !!p);
+  const own = paths.filter((p) => p.length === 1).map((p) => p[0]);
+  const info = paths.filter((p) => p.length === 2);
+  const infoName = info[0]?.[0];
+  const infoSel = infoName ? ` ${infoName} { ${[...new Set(info.map((p) => p[1]))].join(" ")} }` : "";
+  const items = shape.node ? `${shape.items} { ${shape.node} ${inner} }` : `${shape.items} ${inner}`;
+  return `{ ${items}${own.length ? ` ${[...new Set(own)].join(" ")}` : ""}${infoSel} }`;
+};
+var at = (v, path) => {
+  if (!path)
+    return;
+  let cur = v;
+  for (const k of path)
+    cur = cur && typeof cur === "object" ? cur[k] : undefined;
+  return cur;
+};
+var readShape = (shape, v) => {
+  const objs = (xs) => Array.isArray(xs) ? xs.filter((x) => !!x && typeof x === "object") : [];
+  if (v === null || v === undefined)
+    return { items: [], info: {} };
+  if (shape.kind === "object")
+    return { items: objs([v]), info: {} };
+  if (shape.kind === "list")
+    return { items: objs(v), info: {} };
+  const raw = objs(at(v, [shape.items]));
+  const items = shape.node ? objs(raw.map((e) => e[shape.node])) : raw;
+  const hasNext = at(v, shape.hasNext);
+  const next = at(v, shape.next);
+  const total = at(v, shape.total);
+  return {
+    items,
+    info: {
+      ...typeof hasNext === "boolean" ? { hasNext } : {},
+      ...typeof next === "string" && next ? { next } : {},
+      ...typeof next === "number" ? { next: String(next) } : {},
+      ...typeof total === "number" ? { total } : {}
+    }
+  };
+};
+var IDENTITY = ["id", "uid", "slug", "key", "name"];
+var buildSelection = (s, type, depth, exclude = new Set, above = []) => {
+  const t = s.types.get(type);
+  if (!t?.fields)
+    return null;
+  const parts = [];
+  for (const f of t.fields) {
+    if (f.name.startsWith("__") || exclude.has(`${type}.${f.name}`))
+      continue;
+    if (f.args.some(isRequired))
+      continue;
+    const u = unwrap(f.type);
+    if (isLeaf(s, u.name)) {
+      parts.push(f.name);
+      continue;
+    }
+    if (!isComposite(s, u.name))
+      continue;
+    const shape = shapeOf(s, f);
+    if (pageable(planArgs(s, f.args)) || shape?.kind === "page")
+      continue;
+    const sub = depth > 0 && ![...above, type].includes(u.name) ? buildSelection(s, u.name, depth - 1, exclude, [...above, type]) : identitySelection(s, u.name, exclude);
+    if (sub)
+      parts.push(`${f.name} ${sub}`);
+  }
+  return parts.length ? `{ ${parts.join(" ")} }` : null;
+};
+var identitySelection = (s, type, exclude = new Set) => {
+  const fields = (s.types.get(type)?.fields ?? []).filter((f) => IDENTITY.includes(f.name) && !exclude.has(`${type}.${f.name}`) && !f.args.some(isRequired) && isLeaf(s, unwrap(f.type).name));
+  return fields.length ? `{ ${fields.map((f) => f.name).join(" ")} }` : null;
+};
+var typeFieldAt = (s, path) => {
+  let type = s.query;
+  let last;
+  for (const seg of path) {
+    if (typeof seg === "number")
+      continue;
+    const f = fieldOf2(s, type, seg);
+    if (!f)
+      return;
+    last = `${type}.${seg}`;
+    type = unwrap(f.type).name;
+  }
+  return last;
+};
+var findSection = (s, patterns, maxSteps = 4) => {
+  for (const re of patterns) {
+    let frontier = [{ type: s.query, steps: [] }];
+    for (let d = 0;d < maxSteps && frontier.length; d++) {
+      const next = [];
+      for (const { type, steps } of frontier) {
+        for (const f of s.types.get(type)?.fields ?? []) {
+          const shape = shapeOf(s, f);
+          if (!shape)
+            continue;
+          const args = planArgs(s, f.args);
+          if (args.missing.length)
+            continue;
+          if (d === 0 && !args.org.length)
+            continue;
+          const step = { field: f, parent: type, args, shape };
+          if (re.test(f.name) && shape.kind !== "object")
+            return [...steps, step];
+          if (shape.kind === "page" || pageable(args) || args.start || args.end)
+            continue;
+          if (steps.some((x) => x.shape.item === shape.item) || shape.item === s.query)
+            continue;
+          next.push({ type: shape.item, steps: [...steps, step] });
+        }
+      }
+      frontier = next;
+    }
+  }
+  return;
+};
+var structural = (steps) => {
+  const out = new Set;
+  for (const st of steps) {
+    out.add(`${st.parent}.${st.field.name}`);
+    if (st.shape.kind === "page") {
+      const pageType = unwrap(st.field.type).name;
+      out.add(`${pageType}.${st.shape.items}`);
+    }
+  }
+  return out;
+};
+
+// src/sleuth/export.ts
+var SECTIONS = [
+  { name: "deploys", patterns: [/^orgChanges$/, /^changes$/, /^deploys$/], byMonth: true },
+  { name: "projects", patterns: [/^projects$/] },
+  { name: "deployments", patterns: [/^deployments$/, /^codeDeployments$/] },
+  { name: "environments", patterns: [/^environments$/] },
+  { name: "teams", patterns: [/^teams$/] },
+  { name: "labels", patterns: [/^labels$/] },
+  { name: "impactSources", patterns: [/^impactSources$/] },
+  { name: "incidents", patterns: [/^incidents$/, /^orgIncidents$/, /incidents$/i], byMonth: true },
+  {
+    name: "flagEvents",
+    patterns: [
+      /^(flagEvents|featureFlagEvents|flagChanges|featureFlagChanges)$/,
+      /flag\w*(event|change)s$/i
+    ],
+    byMonth: true
+  }
+];
+var DAY = 86400000;
+var MIN_PAGE = 10;
+var MAX_PAGES = 5000;
+var MONTH_BUDGET = 8;
+var MAX_FAILED_MONTHS = 3;
+var NESTED_SIZE = 500;
+var MAX_WARNINGS = 200;
+var DATE_KEYS = [
+  "date",
+  "deployedAt",
+  "deployDate",
+  "createdAt",
+  "startedAt",
+  "occurredAt",
+  "timestamp",
+  "time",
+  "created"
+];
+var MONTH = /^(\d{4})-(0[1-9]|1[0-2])$/;
+var monthsBetween = (since, until) => {
+  const a = MONTH.exec(since);
+  const b = MONTH.exec(until);
+  if (!a || !b)
+    return [];
+  const out = [];
+  let y = Number(a[1]);
+  let m = Number(a[2]);
+  const endKey = Number(b[1]) * 12 + Number(b[2]);
+  while (y * 12 + m <= endKey) {
+    out.push(`${y}-${String(m).padStart(2, "0")}`);
+    m++;
+    if (m > 12) {
+      m = 1;
+      y++;
+    }
+  }
+  return out;
+};
+var monthWindow = (month) => {
+  const [y, m] = month.split("-").map(Number);
+  return { start: new Date(Date.UTC(y, m - 1, 1)), end: new Date(Date.UTC(y, m, 1)) };
+};
+var monthOf = (d) => d.toISOString().slice(0, 7);
+var keyOf2 = (item) => {
+  for (const k of ["id", "uid"]) {
+    const v = item[k];
+    if (typeof v === "string" || typeof v === "number")
+      return `${k}:${v}`;
+  }
+  if (typeof item.slug === "string")
+    return `slug:${JSON.stringify(item._parents ?? {})}:${item.slug}`;
+  return `json:${JSON.stringify(item)}`;
+};
+var itemMonth = (item) => {
+  for (const k of DATE_KEYS) {
+    const v = item[k];
+    if (typeof v !== "string" && typeof v !== "number")
+      continue;
+    const d = new Date(v);
+    if (!Number.isNaN(d.getTime()))
+      return monthOf(d);
+  }
+  return;
+};
+var IDENTITY2 = ["id", "uid", "slug", "key", "name"];
+var identity = (item) => Object.fromEntries(IDENTITY2.filter((k) => item[k] !== undefined).map((k) => [k, item[k]]));
+var writeAtomic = (path, body) => {
+  mkdirSync28(dirname25(path), { recursive: true });
+  const tmp = `${path}.partial`;
+  writeFileSync28(tmp, body);
+  renameSync13(tmp, path);
+};
+var jsonl = (items) => items.length ? `${items.map((i) => JSON.stringify(i)).join(`
+`)}
+` : "";
+var readJsonl = (path) => readFileSync32(path, "utf8").split(`
+`).filter((l) => l.trim()).map((l) => JSON.parse(l));
+var CANNOT_QUERY = /Cannot query field "(\w+)" on type "(\w+)"/;
+var TOO_DEEP = /\bmax(imum)?\b.{0,24}\bdepth\b|\btoo deep\b/i;
+var exportSleuth = async (o) => {
+  const log = o.log ?? (() => {});
+  const now = (o.now ?? (() => new Date))();
+  const currentMonth = monthOf(now);
+  const exclude = new Set;
+  const warnings = new Set;
+  const warn = (line) => {
+    if (warnings.size < MAX_WARNINGS)
+      warnings.add(line);
+  };
+  const manifest = {
+    v: 1,
+    tool: "sleds sleuth export",
+    ...o.cliVersion ? { cliVersion: o.cliVersion } : {},
+    org: o.org,
+    endpoint: o.endpoint,
+    startedAt: now.toISOString(),
+    since: o.since,
+    until: o.until,
+    depth: o.depth,
+    pageSize: o.pageSize,
+    schema: { file: "schema.json", types: 0 },
+    sections: {},
+    pruned: [],
+    warnings: [],
+    mismatches: [],
+    requests: 0,
+    complete: false
+  };
+  const save = () => {
+    manifest.pruned = [...exclude].sort();
+    manifest.warnings = [...warnings];
+    manifest.requests = o.client.calls();
+    writeAtomic(join34(o.out, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+  };
+  mkdirSync28(o.out, { recursive: true });
+  log("reading Sleuth's schema");
+  const intro = await o.client.request(INTROSPECTION_QUERY);
+  if (!intro.data?.__schema)
+    throw new SleuthError(`Sleuth did not answer the schema query${intro.errors[0] ? ` — ${intro.errors[0].message}` : ""}`, false);
+  writeAtomic(join34(o.out, "schema.json"), `${JSON.stringify(intro.data, null, 2)}
+`);
+  const schema = indexSchema(intro.data);
+  manifest.schema.types = schema.types.size;
+  const fitDepth = new Map;
+  const ask = async (build, steps) => {
+    const keep = structural(steps);
+    const root = steps[0]?.field.name ?? "";
+    const path = steps.map((s) => s.field.name).join(".");
+    let depth = fitDepth.get(path) ?? o.depth;
+    for (let i = 0;i < 25; i++) {
+      const r = await o.client.request(build(depth));
+      if (r.data && !r.errors.length)
+        return r.data;
+      const tooDeep = r.errors.some((e) => TOO_DEEP.test(e.message));
+      if (!r.data && tooDeep && depth > 0) {
+        depth--;
+        fitDepth.set(path, depth);
+        log(`sleuth said the query was too deep — reading nested objects ${depth} deep`);
+        continue;
+      }
+      const prune = new Set;
+      for (const e of r.errors) {
+        const m = CANNOT_QUERY.exec(e.message);
+        const tf = e.path && typeFieldAt(schema, e.path) || (m ? `${m[2]}.${m[1]}` : undefined);
+        if (tf && !keep.has(tf) && !exclude.has(tf))
+          prune.add(tf);
+      }
+      const empty = !r.data || r.data[root] === null || r.data[root] === undefined;
+      if (empty && prune.size) {
+        for (const tf of prune) {
+          exclude.add(tf);
+          log(`sleuth refused ${tf} — leaving it out`);
+        }
+        continue;
+      }
+      const why = r.errors.slice(0, 3).map((e) => e.message).join("; ");
+      if (empty)
+        throw new SleuthError(why || "Sleuth answered with no data", !tooDeep);
+      for (const e of r.errors) {
+        const tf = e.path ? typeFieldAt(schema, e.path) : undefined;
+        warn(`${tf ? `${tf}: ` : ""}${e.message}`);
+      }
+      return r.data;
+    }
+    throw new SleuthError("Sleuth kept refusing fields after 25 tries", false);
+  };
+  const buildQuery = (steps, leafValues, depth) => {
+    const last = steps.length - 1;
+    const argsAt = (i) => {
+      const st = steps[i];
+      if (i === last)
+        return renderArgs(st.args, leafValues);
+      return renderArgs(st.args, { org: o.org, ...st.args.size ? { size: NESTED_SIZE } : {} });
+    };
+    const leaf = steps[last];
+    const render = (d) => {
+      const sel = buildSelection(schema, leaf.shape.item, d, exclude) ?? "{ __typename }";
+      let inner = `${leaf.field.name}${argsAt(last)} ${wrapShape(leaf.shape, sel)}`;
+      for (let i = last - 1;i >= 0; i--) {
+        const st = steps[i];
+        const ident = identitySelection(schema, st.shape.item, exclude);
+        const body = `{ ${ident ? `${ident.slice(2, -2)} ` : ""}${inner} }`;
+        inner = `${st.field.name}${argsAt(i)} ${wrapShape(st.shape, body)}`;
+      }
+      return `query { ${inner} }`;
+    };
+    let d = depth;
+    let q = render(d);
+    while (d > 0 && queryDepth(q) > MAX_QUERY_DEPTH)
+      q = render(--d);
+    if (d < o.depth)
+      warn(`${leaf.field.name}: nested objects read ${d} deep, not ${o.depth} — Sleuth's max depth`);
+    return q;
+  };
+  const extract = (steps, data) => {
+    let level = [
+      { value: data[steps[0]?.field.name ?? ""], parents: {} }
+    ];
+    const items = [];
+    const infos = [];
+    steps.forEach((st, i) => {
+      const next = [];
+      for (const { value, parents } of level) {
+        const r = readShape(st.shape, value);
+        if (i === steps.length - 1) {
+          infos.push(r.info);
+          for (const it of r.items)
+            items.push(Object.keys(parents).length ? { ...it, _parents: parents } : it);
+          continue;
+        }
+        const child = steps[i + 1]?.field.name ?? "";
+        for (const it of r.items)
+          next.push({ value: it[child], parents: { ...parents, [st.shape.item]: identity(it) } });
+      }
+      level = next;
+    });
+    return { items, infos };
+  };
+  const fetchItems = async (steps, win, size) => {
+    const leaf = steps[steps.length - 1];
+    const a = leaf.args;
+    const oneParent = steps.slice(0, -1).every((s) => s.shape.kind === "object");
+    const canPage = oneParent && pageable(a);
+    const out = [];
+    let cursor;
+    let page = a.page?.first ?? 1;
+    let offset = 0;
+    let prevFirst;
+    let total;
+    for (let n = 0;n < MAX_PAGES; n++) {
+      const values = {
+        org: o.org,
+        ...win ? { start: win.start, end: win.end } : {},
+        ...a.size ? { size: canPage ? size : Math.max(size, NESTED_SIZE) } : {},
+        ...canPage && a.cursor && cursor ? { cursor } : {},
+        ...canPage && a.page ? { page } : {},
+        ...canPage && !a.cursor && !a.page && a.offset ? { offset } : {}
+      };
+      const data = await ask((depth) => buildQuery(steps, values, depth), steps);
+      const { items, infos } = extract(steps, data);
+      if (!canPage) {
+        const full = oneParent && a.size !== undefined && items.length >= (values.size ?? 0);
+        const truncated = infos.filter((i) => i.hasNext === true).length || (full ? 1 : 0);
+        return {
+          items,
+          truncated,
+          ...oneParent && infos[0]?.total !== undefined ? { total: infos[0].total } : {}
+        };
+      }
+      const info = infos[0] ?? {};
+      if (n === 0 && info.total !== undefined)
+        total = info.total;
+      if (!items.length)
+        break;
+      const first = keyOf2(items[0]);
+      if (first === prevFirst) {
+        warn(`${leaf.field.name}: the next page repeated the last one — paging stopped there`);
+        break;
+      }
+      prevFirst = first;
+      out.push(...items);
+      if (info.hasNext === false)
+        break;
+      if (a.cursor) {
+        if (!info.next || info.next === cursor)
+          break;
+        cursor = info.next;
+        continue;
+      }
+      if (info.hasNext === undefined && a.size && items.length < size)
+        break;
+      if (a.page)
+        page = info.next && /^\d+$/.test(info.next) ? Number(info.next) : page + 1;
+      else
+        offset += items.length;
+    }
+    return { items: out, truncated: 0, ...total !== undefined ? { total } : {} };
+  };
+  const adaptive = async (steps, win, size, budget) => {
+    try {
+      return await fetchItems(steps, win, size);
+    } catch (e) {
+      if (!(e instanceof SleuthError) || !e.adaptable || budget.left <= 0)
+        throw e;
+      budget.left--;
+      const leaf = steps[steps.length - 1];
+      if (leaf.args.size && size > MIN_PAGE) {
+        const half = Math.max(MIN_PAGE, Math.floor(size / 2));
+        log(`  ${e.message} — trying pages of ${half}`);
+        return adaptive(steps, win, half, budget);
+      }
+      const days = win ? Math.floor((win.end.getTime() - win.start.getTime()) / DAY) : 0;
+      if (!win || days < 2)
+        throw e;
+      const mid = new Date(win.start.getTime() + Math.floor(days / 2) * DAY);
+      log(`  ${e.message} — splitting ${win.start.toISOString().slice(0, 10)}…${win.end.toISOString().slice(0, 10)} in two`);
+      const x = await adaptive(steps, { start: win.start, end: mid }, size, budget);
+      const y = await adaptive(steps, { start: mid, end: win.end }, size, budget);
+      return {
+        items: [...x.items, ...y.items],
+        truncated: x.truncated + y.truncated,
+        ...x.total !== undefined && y.total !== undefined ? { total: x.total + y.total } : {}
+      };
+    }
+  };
+  const months = monthsBetween(o.since, o.until);
+  const runSection = async (sec) => {
+    const steps = findSection(schema, sec.patterns);
+    if (!steps)
+      return { found: false, why: "Sleuth's schema has no field by that name" };
+    const leaf = steps[steps.length - 1];
+    const res = {
+      found: true,
+      path: steps.map((s) => s.field.name),
+      windowed: windowed(leaf.args),
+      paged: pageable(leaf.args),
+      count: 0,
+      duplicates: 0
+    };
+    const seen = new Set;
+    const fresh = (items) => {
+      const kept = [];
+      for (const it of items) {
+        const k = keyOf2(it);
+        if (seen.has(k))
+          res.duplicates++;
+        else {
+          seen.add(k);
+          kept.push(it);
+        }
+      }
+      return kept;
+    };
+    if (sec.byMonth && res.windowed) {
+      res.months = [];
+      let failedInARow = 0;
+      for (const month of months) {
+        const file = `${sec.name}/${month}.jsonl`;
+        const path = join34(o.out, file);
+        if (!o.fresh && month < currentMonth && existsSync31(path)) {
+          const kept = fresh(readJsonl(path));
+          res.months.push({ month, file, count: kept.length, resumed: true });
+          res.count += kept.length;
+          continue;
+        }
+        try {
+          const got = await adaptive(steps, monthWindow(month), o.pageSize, { left: MONTH_BUDGET });
+          const kept = fresh(got.items);
+          writeAtomic(path, jsonl(kept));
+          res.months.push({
+            month,
+            file,
+            count: kept.length,
+            ...got.items.length !== kept.length ? { fetched: got.items.length } : {},
+            ...got.total !== undefined ? { total: got.total } : {}
+          });
+          res.count += kept.length;
+          if (got.truncated)
+            res.truncated = (res.truncated ?? 0) + got.truncated;
+          log(`${sec.name} ${month}: ${kept.length}`);
+          failedInARow = 0;
+        } catch (e) {
+          const why = e instanceof Error ? e.message : String(e);
+          res.months.push({ month, file, count: 0, error: why });
+          log(`${sec.name} ${month}: failed — ${why}`);
+          if (++failedInARow >= MAX_FAILED_MONTHS) {
+            res.error = `${MAX_FAILED_MONTHS} months in a row failed; stopped at ${month} — ${why}`;
+            break;
+          }
+        }
+      }
+      return res;
+    }
+    const got = await adaptive(steps, undefined, o.pageSize, { left: MONTH_BUDGET });
+    const kept = fresh(got.items);
+    res.count = kept.length;
+    if (got.truncated)
+      res.truncated = got.truncated;
+    if (!sec.byMonth) {
+      res.file = `${sec.name}.jsonl`;
+      writeAtomic(join34(o.out, res.file), jsonl(kept));
+      log(`${sec.name}: ${kept.length}`);
+      return res;
+    }
+    const byMonth = new Map;
+    for (const it of kept) {
+      const m = itemMonth(it) ?? "undated";
+      byMonth.set(m, [...byMonth.get(m) ?? [], it]);
+    }
+    res.months = [...byMonth.keys()].sort().map((month) => {
+      const file = `${sec.name}/${month}.jsonl`;
+      const list = byMonth.get(month) ?? [];
+      writeAtomic(join34(o.out, file), jsonl(list));
+      return { month, file, count: list.length };
+    });
+    log(`${sec.name}: ${kept.length} (not windowed by Sleuth; filed by each item's date)`);
+    return res;
+  };
+  const orgRoot = (schema.types.get(schema.query)?.fields ?? []).find((f) => {
+    const sh = shapeOf(schema, f);
+    const args = planArgs(schema, f.args);
+    return /^(organization|org)$/i.test(f.name) && sh?.kind === "object" && args.org.length && !args.missing.length;
+  });
+  if (orgRoot) {
+    const steps = [
+      {
+        field: orgRoot,
+        parent: schema.query,
+        args: planArgs(schema, orgRoot.args),
+        shape: { kind: "object", item: unwrap(orgRoot.type).name }
+      }
+    ];
+    try {
+      const sel = buildSelection(schema, unwrap(orgRoot.type).name, 0, exclude) ?? "{ __typename }";
+      const data = await ask(() => `query { ${orgRoot.name}${renderArgs(steps[0]?.args ?? { org: [], missing: [] }, { org: o.org })} ${sel} }`, steps);
+      writeAtomic(join34(o.out, "organization.json"), `${JSON.stringify(data[orgRoot.name], null, 2)}
+`);
+      manifest.organization = { file: "organization.json" };
+    } catch (e) {
+      manifest.organization = { error: e instanceof Error ? e.message : String(e) };
+    }
+  } else
+    manifest.organization = { error: "Sleuth's schema has no organization(orgSlug) field" };
+  save();
+  for (const sec of SECTIONS) {
+    if (o.only?.length && !o.only.includes(sec.name))
+      continue;
+    log(`— ${sec.name}`);
+    try {
+      manifest.sections[sec.name] = await runSection(sec);
+    } catch (e) {
+      manifest.sections[sec.name] = {
+        found: true,
+        path: [],
+        windowed: false,
+        paged: false,
+        count: 0,
+        duplicates: 0,
+        error: e instanceof Error ? e.message : String(e)
+      };
+      log(`${sec.name}: failed — ${e instanceof Error ? e.message : String(e)}`);
+    }
+    save();
+  }
+  const deploys = manifest.sections.deploys;
+  const recap = orgRoot ? fieldOf2(schema, unwrap(orgRoot.type).name, "metricsRecap") : undefined;
+  const recapArgs = recap ? planArgs(schema, recap.args) : undefined;
+  if (orgRoot && recap && recapArgs && windowed(recapArgs) && !recapArgs.missing.length && fieldOf2(schema, unwrap(recap.type).name, "numOfDeploys") && deploys?.found && deploys.months) {
+    const orgArgs = renderArgs(planArgs(schema, orgRoot.args), { org: o.org });
+    for (const row of deploys.months) {
+      if (row.error || row.month === "undated")
+        continue;
+      const w = monthWindow(row.month);
+      try {
+        const r = await o.client.request(`query { ${orgRoot.name}${orgArgs} { ${recap.name}${renderArgs(recapArgs, { start: w.start, end: w.end })} { numOfDeploys } } }`);
+        const orgData = r.data?.[orgRoot.name];
+        const n = orgData?.[recap.name]?.numOfDeploys;
+        if (typeof n === "number")
+          row.sleuthReports = n;
+      } catch (e) {
+        warn(`metricsRecap ${row.month}: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
+  for (const [name, sec] of Object.entries(manifest.sections)) {
+    if (!sec.found || !sec.months)
+      continue;
+    for (const row of sec.months) {
+      const fetched = row.fetched ?? row.count;
+      if (row.total !== undefined && row.total !== fetched)
+        manifest.mismatches.push({
+          section: name,
+          month: row.month,
+          exported: fetched,
+          reported: row.total,
+          source: "totalCount"
+        });
+      if (row.sleuthReports !== undefined && row.sleuthReports !== row.count)
+        manifest.mismatches.push({
+          section: name,
+          month: row.month,
+          exported: row.count,
+          reported: row.sleuthReports,
+          source: "metricsRecap"
+        });
+    }
+  }
+  manifest.finishedAt = new Date().toISOString();
+  manifest.complete = !!orgRoot && Object.values(manifest.sections).every((s) => !s.found || !s.error && !(s.months ?? []).some((m) => m.error));
+  save();
+  return manifest;
+};
+
+// src/commands/sleuth.ts
+var SLEUTH_USAGE = `usage: sleds sleuth export --org <slug> --out <dir> [options]
+
+  Archive a Sleuth.io org through its GraphQL API: the schema, the organization, every deploy
+  (orgChanges) as JSONL by month, and its projects, deployments, environments, teams, labels,
+  impact sources, incidents and flag events, with manifest.json counting each beside what
+  Sleuth reports. Re-run to resume: finished past months on disk are not fetched again.
+
+  SLEUTH_API_KEY        the org's API key or access token (Sleuth › Settings › API)
+  --org <slug>          the Sleuth org slug (required)
+  --out <dir>           where to write (required; created if missing)
+  --since <YYYY-MM>     first month (default 2022-01)
+  --until <YYYY-MM>     last month (default this month)
+  --only <a,b>          just these: ${SECTIONS.map((s) => s.name).join(", ")}
+  --page-size <n>       items a page (default 100; halved on its own when Sleuth struggles)
+  --depth <n>           how deep nested objects are read (default 2)
+  --fresh               fetch every month again, even the ones on disk
+  --url <endpoint>      the GraphQL endpoint (default ${SLEUTH_URL}; else SLEUTH_API_URL)
+  --json                print the manifest instead of the summary`;
+var parse3 = (argv) => {
+  const words = [];
+  const flags = {};
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) {
+      words.push(a);
+      continue;
+    }
+    const eq = a.indexOf("=");
+    if (eq !== -1) {
+      flags[a.slice(2, eq)] = a.slice(eq + 1);
+      continue;
+    }
+    const next = argv[i + 1];
+    if (next !== undefined && !next.startsWith("--")) {
+      flags[a.slice(2)] = next;
+      i++;
+    } else
+      flags[a.slice(2)] = true;
+  }
+  return { words, flags };
+};
+var outDir = (raw, home) => resolve12(raw.startsWith("~/") ? join35(home, raw.slice(2)) : raw);
+var str15 = (f, k) => typeof f[k] === "string" ? f[k] : undefined;
+var MONTH2 = /^\d{4}-(0[1-9]|1[0-2])$/;
+var KNOWN = [
+  "org",
+  "out",
+  "since",
+  "until",
+  "only",
+  "page-size",
+  "depth",
+  "fresh",
+  "url",
+  "json"
+];
+var sleuthCmd = async (o) => {
+  const log = o.log ?? console.log;
+  const error = o.error ?? console.error;
+  const env = o.env ?? process.env;
+  const { words, flags } = parse3(o.argv);
+  const usage = (why) => {
+    if (why)
+      error(why);
+    error(SLEUTH_USAGE);
+    return 2;
+  };
+  if (words[0] !== "export" || words.length !== 1)
+    return usage();
+  const unknown = Object.keys(flags).filter((k) => !KNOWN.includes(k));
+  if (unknown.length)
+    return usage(`unknown option: --${unknown[0]}`);
+  const org = str15(flags, "org");
+  const outRaw = str15(flags, "out");
+  if (!org || !outRaw)
+    return usage("--org and --out are required");
+  const key = env.SLEUTH_API_KEY?.trim();
+  if (!key) {
+    error("SLEUTH_API_KEY is not set — the org's key from Sleuth › Settings › API");
+    return 2;
+  }
+  const now = (o.now ?? (() => new Date))();
+  const since = str15(flags, "since") ?? "2022-01";
+  const until = str15(flags, "until") ?? monthOf(now);
+  if (!MONTH2.test(since) || !MONTH2.test(until) || !monthsBetween(since, until).length)
+    return usage("--since and --until are months, YYYY-MM, since before until");
+  const pageSize = Number(str15(flags, "page-size") ?? 100);
+  const depth = Number(str15(flags, "depth") ?? 2);
+  if (!Number.isInteger(pageSize) || pageSize < 1)
+    return usage("--page-size is a whole number");
+  if (!Number.isInteger(depth) || depth < 0 || depth > 5)
+    return usage("--depth is 0 to 5");
+  const only = str15(flags, "only")?.split(",").map((s) => s.trim()).filter(Boolean);
+  const names = SECTIONS.map((s) => s.name);
+  const bad = only?.find((n) => !names.includes(n));
+  if (bad)
+    return usage(`--only: no section "${bad}" (${names.join(", ")})`);
+  const out = outDir(outRaw, o.home ?? homedir8());
+  const endpoint = str15(flags, "url") ?? env.SLEUTH_API_URL ?? SLEUTH_URL;
+  const version = cliVersion(env);
+  const progress = error;
+  const client = sleuthClient({
+    key,
+    url: endpoint,
+    ...o.fetch ? { fetch: o.fetch } : {},
+    ...o.sleep ? { sleep: o.sleep } : {},
+    log: progress
+  });
+  let manifest;
+  try {
+    manifest = await exportSleuth({
+      org,
+      out,
+      since,
+      until,
+      pageSize,
+      depth,
+      ...only?.length ? { only } : {},
+      fresh: flags.fresh === true,
+      endpoint,
+      ...version ? { cliVersion: version } : {},
+      client,
+      now: () => now,
+      log: progress
+    });
+  } catch (e) {
+    error(`sleuth export stopped — ${e instanceof Error ? e.message : String(e)}`);
+    return e instanceof SleuthError && !e.adaptable ? 2 : 1;
+  }
+  if (flags.json === true) {
+    log(JSON.stringify(manifest));
+    return manifest.complete ? 0 : 1;
+  }
+  log(`Sleuth org ${org} → ${out}`);
+  for (const [name, s] of Object.entries(manifest.sections)) {
+    if (!s.found)
+      log(`  ${name.padEnd(14)} not in Sleuth's schema — skipped`);
+    else {
+      const months = s.months ? ` across ${s.months.length} months` : "";
+      const dupes = s.duplicates ? `, ${s.duplicates} duplicates dropped` : "";
+      const more = s.truncated ? `, ${s.truncated} nested lists cut at one page` : "";
+      log(`  ${name.padEnd(14)} ${String(s.count).padStart(6)}${months}${dupes}${more}${s.error ? ` — FAILED: ${s.error}` : ""}`);
+    }
+  }
+  if (manifest.pruned.length)
+    log(`  Sleuth refused ${manifest.pruned.length} fields: ${manifest.pruned.join(", ")}`);
+  for (const m of manifest.mismatches)
+    log(`  ${m.section} ${m.month}: exported ${m.exported}, Sleuth's ${m.source} says ${m.reported}`);
+  const deploys = manifest.sections.deploys;
+  if (deploys?.found) {
+    const checked = (deploys.months ?? []).filter((r) => r.sleuthReports !== undefined || r.total !== undefined).length;
+    const off = manifest.mismatches.filter((m) => m.section === "deploys").length;
+    if (!checked)
+      log("  Sleuth gave no deploy count to check against");
+    else if (!off)
+      log(`  deploy counts match what Sleuth reports in all ${checked} months checked`);
+  }
+  log(`  ${manifest.requests} requests · manifest.json${manifest.complete ? "" : " — INCOMPLETE: re-run to resume"}`);
+  return manifest.complete ? 0 : 1;
+};
+
 // src/commands/specEvent.ts
 init_meter();
-import { readFileSync as readFileSync32, statSync as statSync8 } from "node:fs";
+import { readFileSync as readFileSync33, statSync as statSync8 } from "node:fs";
 import { basename as basename9, isAbsolute as isAbsolute7, relative as relative2 } from "node:path";
 var HOOK_STDIN_TIMEOUT_MS3 = 1000;
 var ESTIMATE_TIMEOUT_MS = 4000;
@@ -28425,7 +29543,7 @@ function readFileOrNull(path) {
   try {
     if (statSync8(path).size > 2000000)
       return null;
-    return readFileSync32(path, "utf8");
+    return readFileSync33(path, "utf8");
   } catch {
     return null;
   }
@@ -28489,7 +29607,7 @@ var specEvent = async (o) => {
 };
 
 // src/commands/status.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 init_config();
 init_settings();
 var HEALTH_TIMEOUT_MS2 = 4000;
@@ -28577,7 +29695,7 @@ var status3 = async (o) => {
   const log = o.log ?? console.log;
   const nowMs = (o.now ?? Date.now)();
   const cfg = readConfig(o.home);
-  const settings = existsSync31(settingsPath(o.home)) ? readSettings(o.home) : {};
+  const settings = existsSync32(settingsPath(o.home)) ? readSettings(o.home) : {};
   const inSettings = readProxy(settings);
   const picked = selectOrg(cfg, undefined, o.env ?? process.env);
   const viaEnv = picked.from === "env";
@@ -28770,7 +29888,7 @@ var announce = (o, events) => {
 
 // src/commands/stopEvent.ts
 init_meter();
-import { existsSync as existsSync32, readFileSync as readFileSync33 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync34 } from "node:fs";
 
 // src/transcript.ts
 var isObject16 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -28871,7 +29989,7 @@ async function postTranscript(o, payload, now) {
   }
   if (!src)
     return false;
-  const read = o.readFile ?? ((p) => existsSync32(p) ? readFileSync33(p, "utf8") : null);
+  const read = o.readFile ?? ((p) => existsSync33(p) ? readFileSync34(p, "utf8") : null);
   let text;
   try {
     text = read(path);
@@ -28949,7 +30067,7 @@ var stopEvent = async (o) => {
 
 // src/commands/uninstall.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync33, rmSync as rmSync22 } from "node:fs";
+import { existsSync as existsSync34, rmSync as rmSync22 } from "node:fs";
 init_config();
 init_meter();
 init_settings();
@@ -28962,7 +30080,7 @@ var uninstall2 = (o) => {
     (o.log ?? console.log)(`  ${codexLine}`);
   const log = o.log ?? console.log;
   const removed = [];
-  if (existsSync33(settingsPath(o.home))) {
+  if (existsSync34(settingsPath(o.home))) {
     let settings = readSettings(o.home);
     let changed = false;
     const cfg = readConfig(o.home);
@@ -29015,18 +30133,18 @@ var uninstall2 = (o) => {
       writeSettings(o.home, settings);
   }
   for (const file of [meterCachePath(o.home), ...allSeatStatePaths(o.home)]) {
-    if (existsSync33(file)) {
+    if (existsSync34(file)) {
       rmSync22(file, { force: true });
       removed.push(file);
     }
   }
   const skill = skillDir(o.home);
-  if (existsSync33(skill)) {
+  if (existsSync34(skill)) {
     rmSync22(skill, { recursive: true, force: true });
     removed.push(skill);
   }
   const plist = musherPlistPath(o.home);
-  if (existsSync33(plist)) {
+  if (existsSync34(plist)) {
     (o.unloadAgent ?? defaultUnload)(plist);
     rmSync22(plist, { force: true });
     removed.push(`launchd agent ${musherLabel()}`);
@@ -29044,8 +30162,8 @@ var uninstall2 = (o) => {
 
 // src/commands/update.ts
 init_server();
-import { existsSync as existsSync34 } from "node:fs";
-import { homedir as homedir8, userInfo as userInfo4 } from "node:os";
+import { existsSync as existsSync35 } from "node:fs";
+import { homedir as homedir9, userInfo as userInfo4 } from "node:os";
 import { basename as basename10 } from "node:path";
 init_config();
 init_state();
@@ -29111,7 +30229,7 @@ var realPidAlive4 = (pid) => {
 };
 function machineClient(home, env) {
   const src = meterSource(home, undefined, { env });
-  return src ? fetchClient({ ...src, version: "0.1.64" }) : null;
+  return src ? fetchClient({ ...src, version: "0.1.66" }) : null;
 }
 async function noteAnswer2(home, a, now) {
   try {
@@ -29133,7 +30251,7 @@ function busyLine(busy) {
   return `${n} session${n === 1 ? " is" : "s are"} running on ${on} — sleds update --now releases ${n === 1 ? "it" : "them"}`;
 }
 async function updateCmd(o) {
-  const home = o.home ?? homedir8();
+  const home = o.home ?? homedir9();
   const env = o.env ?? process.env;
   const log = o.log ?? console.log;
   const error = o.error ?? console.error;
@@ -29259,7 +30377,7 @@ async function updateCmd(o) {
       error(`sleds ${to} could not be downloaded: ${got.why}`);
       return 1;
     }
-  } else if (!existsSync34(versionBin(home, to, platform))) {
+  } else if (!existsSync35(versionBin(home, to, platform))) {
     error(`sleds ${to} is not on this machine to move back to`);
     return 1;
   }
@@ -29353,7 +30471,7 @@ var verify2 = async (o) => {
 
 // src/commands/webhooks.ts
 var USAGE3 = "usage: sleds webhooks [--json]   |   sleds webhooks deliveries <id or name> [--json]";
-var str15 = (x) => typeof x === "string" ? x : "";
+var str16 = (x) => typeof x === "string" ? x : "";
 function ago3(at, now) {
   const m = Math.max(0, Math.floor((now - at) / 60000));
   if (m < 1)
@@ -29369,7 +30487,7 @@ function webhookLines(raw, now) {
   if (!rows.length)
     return ["no webhooks — add one in the app: Settings › Integrations › Webhooks"];
   return rows.map((h) => {
-    let host = str15(h.url);
+    let host = str16(h.url);
     try {
       host = new URL(host.replace(/\{[a-z.]+\}/g, "x")).host;
     } catch {}
@@ -29377,21 +30495,21 @@ function webhookLines(raw, now) {
     const last = h.lastDelivery;
     const lastText = last?.at ? `last ${last.status ?? "—"} ${last.state ?? ""} ${ago3(last.at, now)}`.replace(/\s+/g, " ") : "nothing sent yet";
     const off = h.enabled ? "on " : "off";
-    const why = !h.enabled && h.disabledWhy ? ` (${str15(h.disabledWhy)})` : "";
-    return `${off}  ${str15(h.name)}  ${host}  ${events.includes("*") ? "all events" : events.join(",")}  ${lastText}${why}  [${str15(h.id)}]`;
+    const why = !h.enabled && h.disabledWhy ? ` (${str16(h.disabledWhy)})` : "";
+    return `${off}  ${str16(h.name)}  ${host}  ${events.includes("*") ? "all events" : events.join(",")}  ${lastText}${why}  [${str16(h.id)}]`;
   });
 }
 function deliveryLines(raw, now) {
   const j = clean(raw);
   const rows = Array.isArray(j.deliveries) ? j.deliveries : [];
-  const name = str15(j.webhook?.name);
+  const name = str16(j.webhook?.name);
   if (!rows.length)
     return [`${name}: nothing sent yet`];
   return [
     `${name} — the last ${rows.length}`,
     ...rows.map((d) => {
-      const result = d.status !== null && d.status !== undefined ? String(d.status) : str15(d.error) || "—";
-      return `${str15(d.state).padEnd(9)} ${result.padEnd(5)} ${str15(d.event).padEnd(20)} ${str15(d.key) || "—"}  ${ago3(Number(d.at), now)}  tries ${d.attempts}  ${str15(d.deliveryId)}`;
+      const result = d.status !== null && d.status !== undefined ? String(d.status) : str16(d.error) || "—";
+      return `${str16(d.state).padEnd(9)} ${result.padEnd(5)} ${str16(d.event).padEnd(20)} ${str16(d.key) || "—"}  ${ago3(Number(d.at), now)}  tries ${d.attempts}  ${str16(d.deliveryId)}`;
     })
   ];
 }
@@ -29422,7 +30540,7 @@ var webhooksCmd = async (o) => {
     return 1;
   }
   if (r.status !== 200 || !r.json) {
-    const why = str15(r.json?.error) || `HTTP ${r.status}`;
+    const why = str16(r.json?.error) || `HTTP ${r.status}`;
     error(r.status === 404 && !r.json ? "SLEDS does not know this seat — run `sleds init`" : why);
     return 1;
   }
@@ -29436,13 +30554,13 @@ var webhooksCmd = async (o) => {
 
 // src/config.ts
 init_settings();
-import { chmodSync as chmodSync8, existsSync as existsSync35, mkdirSync as mkdirSync28, readFileSync as readFileSync34, renameSync as renameSync13, writeFileSync as writeFileSync28 } from "node:fs";
-import { join as join34, resolve as resolve12 } from "node:path";
+import { chmodSync as chmodSync8, existsSync as existsSync36, mkdirSync as mkdirSync29, readFileSync as readFileSync35, renameSync as renameSync14, writeFileSync as writeFileSync29 } from "node:fs";
+import { join as join36, resolve as resolve13 } from "node:path";
 var configDir2 = (home, env = process.env) => {
   const o = env.SLEDS_HOME?.trim();
-  return o ? resolve12(home, o) : join34(home, ".config", "sleds");
+  return o ? resolve13(home, o) : join36(home, ".config", "sleds");
 };
-var configPath2 = (home) => join34(configDir2(home), "config.json");
+var configPath2 = (home) => join36(configDir2(home), "config.json");
 var isObject17 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var optString2 = (v) => typeof v === "string" ? v : undefined;
 var parsePriorEnv2 = (v) => {
@@ -29577,9 +30695,9 @@ var parseOrgInfo2 = (raw) => {
 };
 var readConfig2 = (home) => {
   const p = configPath2(home);
-  if (!existsSync35(p))
+  if (!existsSync36(p))
     return {};
-  return parseConfig2(JSON.parse(readFileSync34(p, "utf8")));
+  return parseConfig2(JSON.parse(readFileSync35(p, "utf8")));
 };
 
 // src/runners/exec.ts
@@ -29636,10 +30754,10 @@ function runnerFor3(name, exec = defaultExec, o = {}) {
 }
 
 // src/runtime.ts
-import { homedir as homedir9 } from "node:os";
-import { join as join35, win32 as win323 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join37, win32 as win323 } from "node:path";
 var isCompiled2 = (argv1 = process.argv[1]) => Boolean(argv1 && (argv1.startsWith("/$bunfs/") || argv1.startsWith("B:\\~BUN\\")));
-var sledsLink2 = (home = homedir9(), platform = process.platform) => platform === "win32" ? win323.join(process.env.LOCALAPPDATA ?? win323.join(home, "AppData", "Local"), "sleds", "bin", "sleds.exe") : join35(home, ".sleds", "bin", "sleds");
+var sledsLink2 = (home = homedir10(), platform = process.platform) => platform === "win32" ? win323.join(process.env.LOCALAPPDATA ?? win323.join(home, "AppData", "Local"), "sleds", "bin", "sleds.exe") : join37(home, ".sleds", "bin", "sleds");
 
 // src/schedule.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
@@ -29651,15 +30769,15 @@ var defaultExec5 = (cmd, args) => {
 };
 
 // src/settings.ts
-import { dirname as dirname25, join as join36, resolve as resolve13 } from "node:path";
+import { dirname as dirname26, join as join38, resolve as resolve14 } from "node:path";
 var withSeatEnv2 = (command, home, env = process.env, org) => {
   const parts = [];
   const sh = env.SLEDS_HOME?.trim();
   const cc = env.CLAUDE_CONFIG_DIR?.trim();
   if (sh)
-    parts.push(`SLEDS_HOME=${shellWord2(resolve13(home, sh))}`);
+    parts.push(`SLEDS_HOME=${shellWord2(resolve14(home, sh))}`);
   if (cc)
-    parts.push(`CLAUDE_CONFIG_DIR=${shellWord2(resolve13(home, cc))}`);
+    parts.push(`CLAUDE_CONFIG_DIR=${shellWord2(resolve14(home, cc))}`);
   parts.push(command);
   return pinOrg4(parts.join(" "), org);
 };
@@ -29745,7 +30863,11 @@ commands:
               --run                  start Claude Code with the pack as the first prompt
   webhooks    The org's outbound webhooks (admins); deliveries <id or name> lists one hook's
               last hundred deliveries. Registering and Redeliver stay in the app.
-  deploy      A release step's one line: tell SLEDS this commit is now running in an environment.
+  sleuth      export --org <slug> --out <dir>: archive a Sleuth.io org before it closes \u2014
+              every deploy as JSONL by month, its projects, environments, teams, incidents and
+              flag events, and a manifest whose counts sit beside Sleuth's own. Key from
+              SLEUTH_API_KEY; re-run to resume. \`sleds sleuth\` alone lists every option.
+  deploy     A release step's one line: tell SLEDS this commit is now running in an environment.
               --env <slug>           the environment (required); --service <name> for a monorepo
               --sha / --repo         else the CI's own variables, then git
               Token from SLEDS_DEPLOY_TOKEN (Settings \u203A Deploys). SLEDS down never fails a release.
@@ -29951,17 +31073,17 @@ var hookStdin = async () => {
 var sledsArgv = (execPath = process.execPath, script = process.argv[1], realpath, o = {}) => {
   if (isCompiled2(script)) {
     const link = sledsLink2(o.home);
-    return stableArgv2([(o.exists ?? existsSync36)(link) ? link : execPath], realpath, o.home);
+    return stableArgv2([(o.exists ?? existsSync37)(link) ? link : execPath], realpath, o.home);
   }
   return stableArgv2(script ? [execPath, script] : [execPath], realpath, o.home);
 };
 var shellQuote = (s) => /^[\w./-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
-var statusLineCommand = (argv, home = homedir10()) => withSeatEnv2([...argv, "statusline"].map(shellQuote).join(" "), home);
-var seatEventCommand = (argv, home = homedir10()) => withSeatEnv2([...argv, "seat-event"].map(shellQuote).join(" "), home);
-var promptEventCommand = (argv, home = homedir10()) => withSeatEnv2([...argv, "prompt-event"].map(shellQuote).join(" "), home);
-var sessionEventCommand = (argv, home = homedir10()) => withSeatEnv2([...argv, "session-event"].map(shellQuote).join(" "), home);
-var stopEventCommand = (argv, home = homedir10()) => withSeatEnv2([...argv, "stop-event"].map(shellQuote).join(" "), home);
-var specEventCommand = (argv, home = homedir10()) => withSeatEnv2([...argv, "spec-event"].map(shellQuote).join(" "), home);
+var statusLineCommand = (argv, home = homedir11()) => withSeatEnv2([...argv, "statusline"].map(shellQuote).join(" "), home);
+var seatEventCommand = (argv, home = homedir11()) => withSeatEnv2([...argv, "seat-event"].map(shellQuote).join(" "), home);
+var promptEventCommand = (argv, home = homedir11()) => withSeatEnv2([...argv, "prompt-event"].map(shellQuote).join(" "), home);
+var sessionEventCommand = (argv, home = homedir11()) => withSeatEnv2([...argv, "session-event"].map(shellQuote).join(" "), home);
+var stopEventCommand = (argv, home = homedir11()) => withSeatEnv2([...argv, "stop-event"].map(shellQuote).join(" "), home);
+var specEventCommand = (argv, home = homedir11()) => withSeatEnv2([...argv, "spec-event"].map(shellQuote).join(" "), home);
 var mcpFlag = (flags) => flags["no-mcp"] === true ? false : flags.mcp === true ? true : undefined;
 var main = async (argv) => {
   const { cmd, flags } = parseArgs(argv);
@@ -29969,7 +31091,7 @@ var main = async (argv) => {
     console.log(commandUsage(cmd));
     return 0;
   }
-  const home = homedir10();
+  const home = homedir11();
   const scheduler = {
     platform: platform3(),
     home,
@@ -29981,7 +31103,7 @@ var main = async (argv) => {
     now: Date.now(),
     stderr: (line) => console.error(line),
     isTTY: !!process.stderr.isTTY,
-    version: "0.1.64"
+    version: "0.1.66"
   });
   switch (cmd) {
     case "update":
@@ -29996,6 +31118,8 @@ var main = async (argv) => {
       return packCmd({ home, argv: argv.slice(1) });
     case "webhooks":
       return webhooksCmd({ home, argv: argv.slice(1) });
+    case "sleuth":
+      return sleuthCmd({ argv: argv.slice(1), home });
     case "deploy":
       return deployCmd({ argv: argv.slice(1) });
     case "sled":
@@ -30214,7 +31338,7 @@ ${renderHelpText(argv[1])}`);
     case "version":
     case "--version":
     case "-v":
-      console.log("sleds 0.1.64");
+      console.log("sleds 0.1.66");
       return 0;
     default:
       console.error(`unknown command: ${cmd}