@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/{chunk-EYWIDJFU.js → chunk-LGBMTVNT.js}

@@ -5,18 +5,20 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   metarepoToolBox
-} from "./chunk-ZVM6AKKM.js";
+} from "./chunk-PJSJPMJI.js";
 import {
   CONTEXT_TOOLS
-} from "./chunk-T6AIP7H5.js";
+} from "./chunk-ISUAAMGS.js";
 import {
   TOOL_LIMITS,
   ToolSession,
   readToolCalls,
   recordToolCalls
-} from "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/context-commands.js

package/dist/{chunk-Q5AMFEWD.js → chunk-LGFL54FP.js}

@@ -15,8 +15,9 @@ import {
   rulesJsonSchemas,
   serializeRecord,
   workspaceJsonSchemas
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/commands.js

package/dist/{chunk-6TACQN3N.js → chunk-LJXMYKZJ.js}

@@ -5,18 +5,20 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   PluginProvider
-} from "./chunk-YEDDOYSC.js";
+} from "./chunk-LYBNHMVZ.js";
 import {
   RuntimeConfigError,
   registerModelProviderPluginLoader
-} from "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/model-plugins.js
 async function pluginProviderFactory(p, deps = {}) {
-  const { readPinnedEntry, runTranslator } = await import("./chunk-HFQCFSJR.js");
+  const { readPinnedEntry, runTranslator } = await import("./chunk-CX4RZ2KS.js");
   const entry = await readPinnedEntry(p.dir, p.manifest);
   if (!entry.ok)
     throw new RuntimeConfigError(`The model-provider plugin org-pack/plugins/model-providers/${p.manifest.id}/ ${entry.message}.`);

package/dist/{chunk-BKVWTZ6A.js → chunk-LKOR5UET.js}

@@ -5,7 +5,7 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   benchFactsCommand
-} from "./chunk-N7IXEHK3.js";
+} from "./chunk-MO6P2JZH.js";
 import {
   BenchStory,
   benchKnownFields,
@@ -15,36 +15,39 @@ import {
   parseReference,
   parseReferenceStory,
   scoreStory
-} from "./chunk-CPA6HPVR.js";
-import "./chunk-BOHJZTEQ.js";
-import "./chunk-MVZVGYXH.js";
-import "./chunk-KEM4SDDP.js";
-import "./chunk-2ANOROX3.js";
-import "./chunk-65NYPGRC.js";
+} from "./chunk-RXPJMEOW.js";
+import "./chunk-WF7B67YE.js";
+import "./chunk-6PPOWY5E.js";
+import "./chunk-O7FDLW7L.js";
+import "./chunk-BTGPE6CR.js";
+import "./chunk-MUWDB4R4.js";
 import {
   draftedStories
-} from "./chunk-CKSITVS4.js";
-import "./chunk-L6SGQIR3.js";
-import "./chunk-3HI6Z55Y.js";
-import "./chunk-XY3P7JW7.js";
-import "./chunk-4AK7IBVP.js";
-import "./chunk-7JUKDRSZ.js";
-import "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-T6AIP7H5.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
+} from "./chunk-R7NYHMUU.js";
+import "./chunk-IVBOQAGB.js";
+import "./chunk-ISUAAMGS.js";
+import "./chunk-S4PMJU6H.js";
+import "./chunk-IDKCWSM5.js";
+import "./chunk-UUU4CLJG.js";
+import "./chunk-7IGKHZ4Z.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
 import {
   changesDirOf,
-  parseFacts,
+  parseFacts
+} from "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import {
   require_dist
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/chunk-LNBQOP7D.js

@@ -0,0 +1,294 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  targetFlowsOf
+} from "./chunk-IH2XURVQ.js";
+import {
+  withFileLock
+} from "./chunk-S7FCV7S5.js";
+import "./chunk-OHNCWBKF.js";
+import {
+  TARGET_DIR,
+  applyStroke,
+  endpointKey,
+  loadEstate,
+  planSketchWrite,
+  readDeltas,
+  writeSketch
+} from "./chunk-R7NYHMUU.js";
+import "./chunk-IVBOQAGB.js";
+import "./chunk-ISUAAMGS.js";
+import "./chunk-S4PMJU6H.js";
+import {
+  changeFolder
+} from "./chunk-IDKCWSM5.js";
+import "./chunk-UUU4CLJG.js";
+import "./chunk-7IGKHZ4Z.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import {
+  labelText,
+  readDrawio
+} from "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import {
+  changesRelOf
+} from "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/change-sketch.js
+import { readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+var METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+function lineParts(text) {
+  const toks = text.trim().split(/\s+/).filter(Boolean);
+  if (toks.length >= 2 && METHODS.has(toks[0].toUpperCase()) && toks[1].startsWith("/"))
+    return { method: toks[0].toUpperCase(), path: toks[1] };
+  if (toks.length === 1 && /^[A-Za-z0-9][\w.-]*\.[\w.-]+$/.test(toks[0]))
+    return { topic: toks[0] };
+  return {};
+}
+function readMermaidSketch(text) {
+  const labels = /* @__PURE__ */ new Map();
+  const lines = [];
+  const problems = [];
+  const legendOf = (s) => {
+    const m = /^\s*[[(]\s*(new|modify|modified|changed|retire|retired|removed)\s*[\])]\s*(.*)$/i.exec(s);
+    if (!m)
+      return { text: s.trim() };
+    const w = m[1].toLowerCase();
+    return {
+      legend: w.startsWith("new") ? "new" : w.startsWith("ret") || w === "removed" ? "retire" : "modify",
+      text: m[2].trim()
+    };
+  };
+  const node = (tok) => {
+    const m = /^([A-Za-z0-9_.-]+)(?:\[\s*"?([^\]"]*)"?\s*\]|\(+\s*"?([^)"]*)"?\s*\)+|\{+\s*"?([^}"]*)"?\s*\}+|>\s*"?([^\]"]*)"?\s*\])?$/.exec(tok.trim());
+    if (!m)
+      return tok.trim();
+    const label = (m[2] ?? m[3] ?? m[4] ?? m[5])?.trim();
+    if (label)
+      labels.set(m[1], label);
+    return m[1];
+  };
+  const rows = text.split(/\r?\n/);
+  rows.forEach((raw, i) => {
+    const row = raw.replace(/%%.*$/, "").trim();
+    if (!row || /^(flowchart|graph)\b/i.test(row) || /^(subgraph|end|classDef|class|style|direction)\b/i.test(row))
+      return;
+    if (/<\s*[-=.]/.test(row)) {
+      problems.push(`line ${i + 1}: a two-way line: draw one line each way: ${row}`);
+      return;
+    }
+    const m = /^(.+?)\s*(?:--+|==+|-\.+-?)\s*(?:\|([^|]*)\||"?([^">=-]*?)"?\s*(?:--+|==+|\.-+))?\s*>\s*(?:\|([^|]*)\|)?\s*(.+)$/.exec(row);
+    if (!m) {
+      if (/^[A-Za-z0-9_.-]+\s*[[({]/.test(row))
+        node(row);
+      else
+        problems.push(`line ${i + 1}: not a box or a line: ${row}`);
+      return;
+    }
+    if (/-->|==>|\.->|&/.test(m[1]) || /-->|==>|\.->|&/.test(m[5])) {
+      problems.push(`line ${i + 1}: one line between two boxes at a time (no chains or &): ${row}`);
+      return;
+    }
+    const from = node(m[1]);
+    const to = node(m[5]);
+    const { legend, text: label } = legendOf((m[2] ?? m[3] ?? m[4] ?? "").trim().replace(/^"(.*)"$/, "$1"));
+    lines.push({
+      from: labels.get(from) ?? from,
+      to: labels.get(to) ?? to,
+      label,
+      ...lineParts(label),
+      ...legend ? { legend } : {},
+      at: `line ${i + 1}`
+    });
+  });
+  for (const l of lines) {
+    l.from = labels.get(l.from) ?? l.from;
+    l.to = labels.get(l.to) ?? l.to;
+  }
+  return { lines, problems };
+}
+function readDrawioSketch(xml) {
+  const d = readDrawio(xml);
+  const lines = d.edges.map((e) => ({
+    from: e.from,
+    to: e.to,
+    label: labelText(e.label),
+    ...e.method ? { method: e.method } : {},
+    ...e.path ? { path: e.path } : {},
+    ...e.topic ? { topic: e.topic } : {},
+    ...e.legend ? { legend: e.legend } : {},
+    at: `${e.page}:${e.line}`
+  }));
+  return { lines, problems: d.problems.map((p) => `${p.cell}: ${p.message}`) };
+}
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+function componentOf(label, estate) {
+  const s = slug(label);
+  const known = (id) => estate.ids.has(id) || estate.flows.some((f) => f.flow.component === id);
+  if (known(label))
+    return label;
+  if (known(s))
+    return s;
+  for (const r of estate.records)
+    if (r.kind === "Component" && (slug(("name" in r && typeof r.name === "string" ? r.name : "") ?? "") === s || slug(r.id) === s))
+      return r.id;
+  return void 0;
+}
+function strokesOfLines(lines, estate, drawnAlready = []) {
+  const plan = { strokes: [], skipped: [] };
+  for (const l of lines) {
+    const from = componentOf(l.from, estate);
+    const to = componentOf(l.to, estate) ?? slug(l.to);
+    if (!from) {
+      plan.skipped.push({
+        line: l,
+        why: `${l.from} isn't a component of the catalog: a stroke can't start from it here (a new box needs a flow name and a trigger; draw it in the app).`
+      });
+      continue;
+    }
+    const entry = l.topic ?? (l.method && l.path ? `${l.method} ${l.path}` : l.label);
+    if (!entry) {
+      plan.skipped.push({
+        line: l,
+        why: "the line has no label: say the API (METHOD /path) or the topic."
+      });
+      continue;
+    }
+    const todaySteps = estate.flows.filter((f) => f.flow.component === from).flatMap((f) => f.flow.steps.map((s, i) => ({ flow: f.flow.id, step: i + 1, s })).filter(({ s }) => s.to?.component === to && (s.to.entry === entry || !!l.path && s.to.entry.replace(/^[A-Z]+\s+/, "") === l.path)));
+    if (l.legend === "retire") {
+      if (!todaySteps.length) {
+        plan.skipped.push({
+          line: l,
+          why: `marked retired, but today's map has no step from ${from} to ${to} ${entry}.`
+        });
+        continue;
+      }
+      for (const t of todaySteps)
+        plan.strokes.push({
+          line: l,
+          stroke: {
+            kind: "remove",
+            flow: t.flow,
+            step: t.step,
+            why: `Removed in the sketch (${l.at}).`
+          }
+        });
+      continue;
+    }
+    if (todaySteps.length && l.legend !== "new") {
+      plan.skipped.push({ line: l, why: "already on today's map; nothing to draw." });
+      continue;
+    }
+    const drawnBefore = drawnAlready.some((d) => (d.repo === from || d.runsOn?.component === from || d.flow.startsWith(`${from}.`)) && d.steps.some((st) => st.op === "add" && (l.topic && st.kind === "publish" && st.to?.entry === l.topic || !l.topic && st.to?.component === to && st.to.entry === entry)));
+    if (drawnBefore) {
+      plan.skipped.push({ line: l, why: "already drawn in this change; nothing to add." });
+      continue;
+    }
+    const isNew = !componentOf(l.to, estate) || !!l.method && !estate.endpoints.has(endpointKey(entry));
+    plan.strokes.push({
+      line: l,
+      stroke: l.topic ? {
+        kind: "topic",
+        from: { component: from },
+        topic: l.topic,
+        ...componentOf(l.to, estate) && to !== from ? { listener: { component: to } } : {},
+        what: `Publishes ${l.topic} (${l.at}).`
+      } : {
+        kind: "call",
+        from: { component: from },
+        to: { component: to, entry, new: isNew },
+        what: `Calls ${to}'s ${entry} (${l.at}).`
+      }
+    });
+  }
+  return plan;
+}
+async function changeSketchCommand(root, change, o, io) {
+  if (!change || !o.from) {
+    io.err("Usage: atticus change sketch <change> --from <file.drawio|.mmd> [--save]");
+    return 2;
+  }
+  const t = await targetFlowsOf(root, change);
+  if (!t) {
+    io.err(`There is no change ${change}.`);
+    return 2;
+  }
+  const text = await readFile(o.from, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`${o.from} can't be read.`);
+    return 2;
+  }
+  const ext = extname(o.from).toLowerCase();
+  const read = ext === ".drawio" || ext === ".xml" || text.trimStart().startsWith("<") ? readDrawioSketch(text) : readMermaidSketch(text);
+  const estate = await loadEstate(root, t.records);
+  const dir = changeFolder(root, change);
+  const plan = strokesOfLines(read.lines, estate, (await readDeltas(dir)).deltas);
+  const by = `${o.by ?? "a person"} from ${basename(o.from)}`;
+  const problems = [...read.problems];
+  const drawn = [];
+  await withFileLock(join(dir, TARGET_DIR), async () => {
+    const read2 = await readDeltas(dir);
+    if (read2.problems.length) {
+      problems.push(...read2.problems.map((x) => `${x} (fix it before drawing over it)`));
+      return;
+    }
+    let deltas = read2.deltas;
+    const changed = [];
+    for (const s of plan.strokes) {
+      const r = applyStroke(deltas, s.stroke, estate, by);
+      if (r.problem) {
+        plan.skipped.push({ line: s.line, why: r.problem });
+        continue;
+      }
+      deltas = r.deltas;
+      changed.push(...r.changed);
+      drawn.push(`${s.line.from} \u2192 ${s.line.to} ${s.line.label} (${s.line.at})`);
+    }
+    if (o.save && drawn.length)
+      await writeSketch(dir, await planSketchWrite(dir, deltas, changed, estate, by));
+  });
+  if (o.json) {
+    io.out(JSON.stringify({
+      change,
+      written: !!o.save && drawn.length > 0,
+      drawn,
+      skipped: plan.skipped,
+      problems
+    }, null, 2));
+    return 0;
+  }
+  for (const d of drawn)
+    io.out(`${o.save ? "Drawn" : "Would draw"}: ${d}`);
+  for (const s of plan.skipped)
+    io.out(`Left out: ${s.line.from} \u2192 ${s.line.to} ${s.line.label} (${s.line.at}): ${s.why}`);
+  for (const p of problems)
+    io.out(`Didn't read: ${p}`);
+  if (!drawn.length) {
+    io.out("Nothing to draw from this file.");
+    return plan.skipped.length || problems.length ? 1 : 0;
+  }
+  io.out(o.save ? `${drawn.length} stroke${drawn.length === 1 ? "" : "s"} written to ${changesRelOf(root)}/${change}/${TARGET_DIR}/; the change diagram shows them, and atticus change architecture ${change} fills in the rest.` : `${drawn.length} stroke${drawn.length === 1 ? "" : "s"} to draw; nothing written. Add --save to draw them.`);
+  return 0;
+}
+export {
+  changeSketchCommand,
+  componentOf,
+  lineParts,
+  readDrawioSketch,
+  readMermaidSketch,
+  strokesOfLines
+};

package/dist/{chunk-O3WI5KWW.js → chunk-LO6P2VYG.js}

@@ -5,11 +5,11 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   baseClonePath
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   loadOrgPack,
   orgPackDirOf
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 
 // packages/cli/dist/repo-for.js
 import { stat } from "node:fs/promises";

package/dist/chunk-LQJPN536.js

@@ -0,0 +1,122 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  estateRepos,
+  joinReposOf,
+  outsideSystems
+} from "./chunk-J2JAKCIW.js";
+import {
+  factIdPart,
+  factsDirOf,
+  joinConventions,
+  joinFacts,
+  loadOrgPack,
+  orgPackDirOf,
+  parseFacts
+} from "./chunk-Q2TECDIT.js";
+
+// packages/cli/dist/onboarding-queue.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var reasonOf = (r) => r.started ? "started" : r.callers?.length ? "called" : r.gateway ? "gateway" : r.places ? "places" : "next";
+function queueOrder(a, b) {
+  const rank = (r) => ["started", "called", "gateway", "places", "next"].indexOf(reasonOf(r));
+  return rank(a) - rank(b) || (b.callers?.length ?? 0) - (a.callers?.length ?? 0) || Number(!!b.gateway) - Number(!!a.gateway) || a.index - b.index;
+}
+function queueWhy(r) {
+  const callers = r.callers ?? [];
+  const named = callers.length > 3 ? `${callers.slice(0, 3).join(", ")} and ${callers.length - 3} more` : callers.join(", ");
+  switch (reasonOf(r)) {
+    case "started":
+      return "Its read is under way: finish it first.";
+    case "called":
+      return `${callers.length} read ${callers.length === 1 ? "repo calls" : "repos call"} it (${named})${r.gateway ? ", and it is a gateway" : ""}: read it next and ${callers.length === 1 ? "that link lands" : "those links land"}.`;
+    case "gateway":
+      return "It is a gateway (its manifest type): the calls through it join once it is read, so it goes before its callers.";
+    case "places":
+      return "It is a deploy or config repo (its manifest type): its Routes and values say where other repos are reached, so their links land once it is read.";
+    default:
+      return "Nothing read yet calls it: in the manifests' order.";
+  }
+}
+var firstLine = (e) => String(e?.message ?? e).split("\n")[0];
+function callersOf(op, read, waiting) {
+  const out = /* @__PURE__ */ new Map();
+  if (!read.length || !waiting.length)
+    return /* @__PURE__ */ new Map();
+  const manifests = estateRepos(op);
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const id of waiting) {
+    const m = manifests.find((r) => r.id === id);
+    byTarget.set(factIdPart(id), id);
+    if (m?.component)
+      byTarget.set(factIdPart(m.component), id);
+    for (const mod of m?.modules ?? [])
+      byTarget.set(factIdPart(mod.component), id);
+  }
+  const repos = joinReposOf(op, [
+    ...read,
+    ...waiting.filter((id) => !read.some((r) => r.repo === id)).map((repo) => ({ repo, facts: [] }))
+  ]);
+  const join2 = joinFacts({ repos, outside: outsideSystems(op), ...joinConventions(op) });
+  for (const m of join2.misses) {
+    const to = byTarget.get(factIdPart(m.target));
+    if (!to || to === m.call.repo)
+      continue;
+    out.set(to, (out.get(to) ?? /* @__PURE__ */ new Set()).add(m.call.repo));
+  }
+  return new Map([...out].map(([k, v]) => [k, [...v].sort()]));
+}
+async function onboardingQueue(root, waiting) {
+  const problems = [];
+  let op;
+  try {
+    op = await loadOrgPack(orgPackDirOf(root));
+  } catch (e) {
+    problems.push({ file: "org-pack", message: firstLine(e) });
+  }
+  const manifests = op ? estateRepos(op) : [];
+  const ids = waiting.map((w) => w.repo);
+  let callers = /* @__PURE__ */ new Map();
+  if (op) {
+    const read = [];
+    for (const m of manifests) {
+      const text = await readFile(join(factsDirOf(root), `${m.id}.jsonl`), "utf8").catch(() => void 0);
+      if (!text?.trim())
+        continue;
+      const p = parseFacts(text);
+      if (p.ok)
+        read.push({ repo: m.id, facts: p.facts });
+    }
+    try {
+      callers = callersOf(op, read, ids);
+    } catch (e) {
+      problems.push({
+        file: "facts",
+        message: `the join couldn't rank the queue: ${firstLine(e)}`
+      });
+    }
+  }
+  const queue = waiting.map((w, index) => {
+    const m = manifests.find((r) => r.id === w.repo);
+    const by = callers.get(w.repo) ?? [];
+    return {
+      repo: w.repo,
+      index,
+      ...w.started ? { started: true } : {},
+      ...m && /^gateway(-|$)/.test(m.type) ? { gateway: true } : {},
+      ...m && /^(deploy|config)(-|$)/.test(m.type) ? { places: true } : {},
+      ...by.length ? { callers: by } : {}
+    };
+  }).sort(queueOrder);
+  return { queue, problems };
+}
+
+export {
+  reasonOf,
+  queueWhy,
+  onboardingQueue
+};

package/dist/{chunk-YEDDOYSC.js → chunk-LYBNHMVZ.js}

@@ -6,12 +6,14 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   RuntimeConfigError,
   RuntimeError,
-  estimateTokens,
   registerModelProvider
-} from "./chunk-CNUKCS2T.js";
+} from "./chunk-P32RUW3B.js";
+import {
+  estimateTokens
+} from "./chunk-Q2TECDIT.js";
 import {
   redactText
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-TUULXQRW.js";
 import {
   __commonJS,
   __require,
@@ -26302,6 +26304,7 @@ var copy = {
   literalKey: (provider, name) => `adapters.model.settings.${name} for the ${provider} model provider looks like a key or token itself. A key never goes in runtime.yaml: put it in an environment variable and give that variable's name as keyEnv (for example keyEnv: ATTICUS_MODEL_KEY).`,
   keyEnvName: (provider) => `adapters.model.settings.keyEnv for the ${provider} model provider must be the name of an environment variable (letters, digits and _, for example ATTICUS_MODEL_KEY), not the key.`,
   keyEnvUnset: (provider, keyEnv) => `The ${provider} model provider reads its key from ${keyEnv}, which is set neither in the environment nor in this machine's credential store. Keep it there with atticus secret set ${keyEnv} (or the AI tab's "Set the key on this machine"), or set the environment variable; the key never goes in runtime.yaml.`,
+  keyEnvNotRead: (provider, keyEnv) => `The ${provider} model provider's keyEnv is ${keyEnv}, which isn't read from the environment: only a variable starting ATTICUS_ (such as ATTICUS_MODEL_KEY) or a model provider's own (such as ANTHROPIC_API_KEY or OPENAI_API_KEY) is, so a runtime.yaml can't send another secret (a Git or pipeline token, cloud credentials) to the model's address. Name one of those in keyEnv, or keep the key with atticus secret set ${keyEnv}.`,
   plainHttp: (provider, url) => `The ${provider} model provider only calls https:// addresses (prompts carry your organisation's material), and ${url} isn't one. Plain http:// is accepted only for this machine (localhost or 127.0.0.1).`,
   awsUnset: (missing) => `AWS Bedrock reads its credentials from the standard AWS environment variables, and ${missing.join(" and ")} ${missing.length === 1 ? "isn't" : "aren't"} set. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY (and AWS_SESSION_TOKEN for temporary credentials) in the environment that runs Atticus.`,
   awsNoRegion: () => "AWS Bedrock needs a region: set adapters.model.settings.region in runtime.yaml (for example region: us-east-1), or AWS_REGION in the environment.",
@@ -26498,6 +26501,24 @@ function looksLikeKey(v) {
   return false;
 }
 var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+var PROVIDER_KEY_ENVS = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "AZURE_OPENAI_API_KEY",
+  "AZURE_OPENAI_KEY",
+  "GEMINI_API_KEY",
+  "MISTRAL_API_KEY",
+  "COHERE_API_KEY",
+  "GROQ_API_KEY",
+  "OPENROUTER_API_KEY",
+  "TOGETHER_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "XAI_API_KEY",
+  "FIREWORKS_API_KEY"
+];
+function keyEnvFromEnvironment(name) {
+  return /^ATTICUS_[A-Z0-9_]+$/.test(name) || PROVIDER_KEY_ENVS.includes(name);
+}
 var SettingsReader = class {
   provider;
   raw;
@@ -26574,9 +26595,10 @@ var SettingsReader = class {
   }
 };
 function readKey(provider, keyEnv, env, store = defaultKeyStore()) {
-  const v = env[keyEnv]?.trim() || store.get(keyEnv)?.trim();
+  const fromEnv = keyEnvFromEnvironment(keyEnv);
+  const v = (fromEnv ? env[keyEnv]?.trim() : void 0) || store.get(keyEnv)?.trim();
   if (!v)
-    throw new ModelProviderConfigError(copy.keyEnvUnset(provider, keyEnv));
+    throw new ModelProviderConfigError(fromEnv ? copy.keyEnvUnset(provider, keyEnv) : copy.keyEnvNotRead(provider, keyEnv));
   return v;
 }
 
@@ -27771,6 +27793,8 @@ export {
   ModelProviderConfigError,
   ModelProviderError,
   looksLikeKey,
+  PROVIDER_KEY_ENVS,
+  keyEnvFromEnvironment,
   SettingsReader,
   readKey,
   TransportError,