@maycombhq/atticus 2.0.0-beta.18 → 2.0.0-beta.21

package/dist/{chunk-VEJYZEPC.js → chunk-K332XW7K.js}

@@ -16,12 +16,12 @@ import {
   outsideSystemsOf,
   phaseGates,
   statePhase
-} from "./chunk-IOW6BF3U.js";
+} from "./chunk-HSZMPH5T.js";
 import {
   daysBetween,
   knowledgeGaps,
   newestEvidence
-} from "./chunk-KCQS52TH.js";
+} from "./chunk-64AADMTW.js";
 import {
   BREAKING_SPEC,
   INSTRUCTION_RULES,
@@ -33,8 +33,9 @@ import {
   screenText,
   settle,
   toRunSummary
-} from "./chunk-QNMLLYTN.js";
+} from "./chunk-QHJJMZLX.js";
 import {
+  ASKED_GAP_STEP,
   AgentDefinition,
   ChecklistPack,
   ChecklistRule,
@@ -43,12 +44,17 @@ import {
   FindingAction,
   HOSTS_STEP,
   IsoDateTime,
+  JOINED_BY_AI,
   LEGACY_LENSES,
   Lens,
   PHASES,
+  QUESTION_SCHEMA_VERSION,
+  Question,
   RECORD_KINDS,
   RecordId,
+  answerByWords,
   answerWords,
+  askedGapQuestionId,
   assistantActor,
   callsOfQuestion,
   changesDirOf,
@@ -69,15 +75,17 @@ import {
   questionOfLens,
   questionsRelOf,
   quotedIn,
+  readQuestion,
   repoReadOf,
   require_dist,
   runsDirOf,
   stateDirOf,
-  toCanonicalYaml
-} from "./chunk-YK6CSODO.js";
+  toCanonicalYaml,
+  writeQuestion
+} from "./chunk-PAINMSID.js";
 import {
   writeFileAtomic
-} from "./chunk-MMB2OHUY.js";
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -618,7 +626,8 @@ function catalogEvidence(ctx, id) {
     recordEvidence(id),
     ...file ? [
       {
-        source: file.source,
+        // ADR 0181: an AI evidence cites the call's own code line; a finding names it as code.
+        source: file.source === "ai" ? "code" : file.source,
         path: file.path,
         ...file.repo ? { repo: file.repo } : {},
         ...file.line ? { line: file.line } : {}
@@ -1290,6 +1299,8 @@ function patternProblems(ctx, o) {
   const doc = docOf(ctx.files, IFACES);
   if (!doc)
     return [];
+  if (ctx.patterns.size === 0)
+    return [];
   const hits = [];
   const codes = [...ctx.patterns.keys()].sort();
   for (const h of ctx.hops) {
@@ -1681,7 +1692,8 @@ var interfaceViaMatchesPattern = {
         evidence: [
           recordEvidence(rec.id),
           ...rec.evidence.filter((e) => e.path).slice(0, 1).map((e) => ({
-            source: e.source,
+            source: e.source === "ai" ? "code" : e.source,
+            // ADR 0181: the call's own line
             path: e.path,
             ...e.repo ? { repo: e.repo } : {},
             ...e.line ? { line: e.line } : {}
@@ -1789,6 +1801,28 @@ var changeLinksKnown = {
           subject: c.caller,
           key: `link-guess|${rec.id}`
         });
+      if (rec && !flag && rec.flags?.includes(JOINED_BY_AI)) {
+        const run = rec.evidence.find((e) => e.source === "ai")?.run;
+        hits.push({
+          kind: "knowledge-gap",
+          ...place,
+          summary: sentence(`The change rests on a link the AI decided: ${c.caller} to ${c.callee} (${c.operation}), detected by AI${run ? ` (run ${run})` : ""} and not confirmed by a person.`),
+          why: `The AI paired this call with ${c.callee}, and Atticus applied it because its lines checked and its shape agreed; nobody has said it is right. If it is wrong, the design is built on a call that goes somewhere else.`,
+          fix: {
+            text: `Confirm or correct it: atticus questions decisions lists it; atticus questions correct (or Correct on the "Detected by AI" chip) makes it a person's word, then atticus verify ${ctx.get("Component", c.caller)?.repo ?? c.caller} --write.`
+          },
+          evidence: [
+            ...place.evidence.filter((e) => e.source !== "catalog"),
+            recordEvidence(rec.id)
+          ],
+          question: {
+            text: `Does ${c.caller}'s ${c.operation} go to ${c.callee}? The AI decided so; nobody has confirmed it.`,
+            owner: questionOwner(ctx, c.caller)
+          },
+          subject: c.caller,
+          key: `link-ai|${rec.id}`
+        });
+      }
       const repo = ctx.get("Component", c.caller)?.repo;
       for (const q of ctx.estate?.questions ?? []) {
         if (!repo || q.question.repo !== repo || !q.calls.some((f) => sameCall(f, c)))
@@ -3231,7 +3265,8 @@ async function changeAnswers(root, change) {
     id: q.id,
     question: q.question.trim(),
     answer: (answerWords(q) ?? "").trim(),
-    by: q.answer.by,
+    // ADR 0181: an AI answer reads as the AI's, never a person's word.
+    by: answerByWords(q.answer.by),
     at: q.answer.at
   })).filter((a) => a.answer.length > 0);
 }
@@ -4205,6 +4240,33 @@ async function sinceReview(root, o) {
 }
 
 // packages/naysayer/dist/ai.js
+var LENS_BATCH_AGENT = "critic-lenses";
+var batchingOf = (rt) => typeof rt.prepareBatch === "function" && typeof rt.canBatch === "function" ? rt : void 0;
+async function batchLenses(ctx, runtime, runs) {
+  const batching = batchingOf(runtime);
+  const waiting = runs.filter((r) => r.state === "waiting" && r.runId);
+  if (!batching || waiting.length < 2)
+    return void 0;
+  const tokens = waiting.reduce((n, r) => n + (r.context?.tokens ?? 0), 0);
+  if (!batching.canBatch(waiting.length, tokens))
+    return void 0;
+  const first = lensAgent(ctx, waiting[0].lens);
+  const batch = await batching.prepareBatch({
+    change: ctx.change.id,
+    agent: {
+      ...first,
+      id: LENS_BATCH_AGENT,
+      description: `The critic's ${waiting.map((r) => r.lens).join(", ")} lenses on change ${ctx.change.id}, asked in one prompt: each lens is its own review, answered in its own section.`,
+      allowedRuntimes: ["hand-off"]
+    },
+    parts: waiting.map((r) => ({ name: r.lens, runId: r.runId })),
+    stepClass: "critic"
+  });
+  const run = await runtime.run(batch.runId);
+  for (const r of waiting)
+    r.batch = run.runId;
+  return run.runId;
+}
 var ALL_INPUTS = [
   "brief",
   "proposal",
@@ -4949,7 +5011,8 @@ async function runLenses(ctx, rules, o) {
       runs.push({ ...base, state: "failed", reason: e.message });
     }
   }
-  return { hits, runs, discarded, skipped, reviewed };
+  const batch = o.runtime && o.batch ? await batchLenses(ctx, o.runtime, runs).catch(() => void 0) : void 0;
+  return { hits, runs, discarded, skipped, reviewed, ...batch ? { batch } : {} };
 }
 
 // packages/naysayer/dist/gates.js
@@ -4972,7 +5035,9 @@ async function gateStatusOf(root, lifecycle, change, gate) {
     return p && f.finding.state === "open" ? { ...f, proposal: p } : f;
   });
   const open = findings.filter((f) => f.finding.state === "open");
-  const blocking = (await checkFindings(root, change, [gate])).map((r) => r.message);
+  const checked = await checkFindings(root, change, [gate]);
+  const blocking = checked.map((r) => r.message);
+  const onlyGaps = checked.length > 0 && checked.every((r) => r.code === "open-gap");
   const waiting = round ? ((await readRoundMeta(root, change.id, gate, round))?.lenses ?? []).filter((l) => l.state === "waiting" && l.runId).map((l) => ({ lens: l.lens, runId: l.runId })) : [];
   const proposed = findings.filter((f) => f.proposal && f.finding.severity === "blocking");
   const reasons = [
@@ -4994,7 +5059,7 @@ async function gateStatusOf(root, lifecycle, change, gate) {
     total: count(findings),
     mayProceed: reasons.length === 0,
     // An open gap with nothing blocking waits on its owner, not on a person's decision.
-    humanDecides: blocking.length > 0 && usedUp && !(count(open).blocking === 0 && count(open).gaps > 0 && waiting.length === 0),
+    humanDecides: blocking.length > 0 && usedUp && !(count(open).blocking === 0 && onlyGaps && waiting.length === 0),
     checkRound: usedUp && (await checkRoundDue(root, change.id, gate)).length > 0,
     checkRoundsRun,
     waiting,
@@ -5315,6 +5380,7 @@ async function runCritic(root, changeId, opts = {}) {
   }) : void 0;
   const ai = await runLenses(ctx, applicable, {
     ...opts.runtime ? { runtime: opts.runtime } : {},
+    ...opts.batchLenses ? { batch: true } : {},
     lenses,
     failed,
     ...opts.maxClassification ? { maxClassification: opts.maxClassification } : {},
@@ -5409,6 +5475,8 @@ async function runCritic(root, changeId, opts = {}) {
       artifacts: r.artifacts,
       ...r.promptSha256 ? { promptSha256: r.promptSha256 } : {},
       ...r.runId ? { runId: r.runId } : {},
+      // ADR 0185: the one prompt it was asked in with the round's other waiting lenses.
+      ...r.batch ? { batch: r.batch } : {},
       // What the lens was sent (ADR 0115 addendum, 2026-10-25): its size, what was cut to
       // need, and in a redraft the round it was diffed against and what wasn't sent.
       ...r.context ? { context: r.context } : {}
@@ -5428,6 +5496,7 @@ async function runCritic(root, changeId, opts = {}) {
     refused: layered.refused,
     problems,
     lenses: ai.runs,
+    ...ai.batch ? { batch: ai.batch } : {},
     discarded: ai.discarded,
     failedLayer1: [...failed].sort(),
     model,
@@ -5570,6 +5639,19 @@ async function completeLensRun(root, run, opts = {}) {
     status: await gateStatusOf(root, lifecycle, change, gateId)
   };
 }
+async function completeLensBatch(root, batch, result, opts = {}) {
+  const out = [];
+  for (const p of batch.parts ?? []) {
+    const run = await result(p.runId).catch(() => void 0);
+    if (run?.state !== "validated" || !lensRunOf(run.request))
+      continue;
+    const found = await roundOf(root, run.request.change, run.runId);
+    if (found?.entry.state !== "waiting")
+      continue;
+    out.push(await completeLensRun(root, run, opts));
+  }
+  return out;
+}
 async function failLens(root, change, gate, round, runId, reason) {
   const meta = await readRoundMeta(root, change, gate, round);
   if (!meta || !meta.lenses.some((l) => l.runId === runId && l.state === "waiting"))
@@ -5583,6 +5665,29 @@ import { createHash } from "node:crypto";
 import { readdir as readdir7, readFile as readFile8 } from "node:fs/promises";
 import { join as join12, normalize, sep as sep2 } from "node:path";
 var import_yaml8 = __toESM(require_dist(), 1);
+async function raiseAskedQuestion(root, f, askedOf, at) {
+  const id = askedGapQuestionId(f.change, f);
+  if (await readQuestion(root, id).catch(() => void 0))
+    return id;
+  const rel = `${changesRelOf(root)}/${f.change}`;
+  const file = f.artifact === "catalog" ? "change.yaml" : f.artifact;
+  const rerun = `atticus critic ${f.change} --gate ${f.gate}`;
+  await writeQuestion(root, Question.parse({
+    schemaVersion: QUESTION_SCHEMA_VERSION,
+    id,
+    askedBy: { step: ASKED_GAP_STEP, command: `atticus finding ${f.change} ${f.id} ask`, at },
+    repo: f.change,
+    question: f.question?.text ?? f.summary,
+    options: [],
+    evidence: [`${rel}/${file}:${f.artifact === "catalog" ? 1 : f.locator.line ?? 1}`],
+    scope: { level: "repo", id: f.change },
+    askedOf,
+    finding: { change: f.change, gate: f.gate, round: f.round, id: f.id },
+    state: "open",
+    rerun
+  }));
+  return id;
+}
 async function locate(lifecycle, root, change, id, gate) {
   const gates = gate ? [gate] : await reviewedGates(root, change);
   const order = lifecycle.orgPack.gates.gates.map((g) => g.id);
@@ -5727,7 +5832,7 @@ async function act(root, changeId, findingId, action, o) {
     const said = o.reason?.trim().replace(/[.!?]+$/, "");
     message = edited.length ? `Recorded your edit to ${edited.join(", ")}.` : said ? `Recorded what you did: ${said}.` : `Recorded your edit to ${f.artifact}.`;
   } else if (act2 === "ask")
-    message = `Asked ${askedOf}. The gap stops blocking while the question is open.`;
+    message = `Asked ${askedOf}.`;
   else if (act2 === "waive")
     message = `Waived ${f.id}. The waiver, its reason and your name are recorded on the finding; it reaches main with the ${f.gate} hand-off PR, where reviewers see it.`;
   else
@@ -5756,6 +5861,11 @@ async function act(root, changeId, findingId, action, o) {
     };
   }
   await writeFinding(root, next.data);
+  let question;
+  if (act2 === "ask" && gap) {
+    question = await raiseAskedQuestion(root, next.data, askedOf, next.data.resolution.at);
+    message = `Asked ${askedOf}: owner question ${question} is in Questions, Owner questions. The ${f.gate} gate waits for its answer.`;
+  }
   if (waiting)
     await writeProposals(root, change.id, f.gate, f.round, proposals.filter((p) => p.finding !== f.id));
   const after = act2 === "ask" ? void 0 : await afterLimit(lifecycle, root, change.id, next.data);
@@ -5763,7 +5873,13 @@ async function act(root, changeId, findingId, action, o) {
     message = `${message} ${after}`;
   else if (act2 === "apply" || act2 === "edit-and-apply")
     message = patched || act2 === "edit-and-apply" ? `${message.replace(/\.$/, "")}; the next critic round checks it.` : `${message} The next critic round checks the fix.`;
-  return { finding: next.data, path: found.path, ...patched ? { patched } : {}, message };
+  return {
+    finding: next.data,
+    path: found.path,
+    ...patched ? { patched } : {},
+    ...question ? { question } : {},
+    message
+  };
 }
 async function afterLimit(ctx, root, change, f) {
   const max = gateRoundLimit(ctx.orgPack.gates, f.gate);
@@ -5815,8 +5931,8 @@ async function editedByPerson(folder) {
     if (!written || typeof written !== "object")
       continue;
     for (const [file, hash] of Object.entries(written)) {
-      const now = await readFile8(join12(folder, ...file.split("/"))).catch(() => void 0);
-      const h = now ? createHash("sha256").update(now).digest("hex") : void 0;
+      const now = await readFile8(join12(folder, ...file.split("/")), "utf8").catch(() => void 0);
+      const h = now !== void 0 ? createHash("sha256").update(now.replace(/\r\n?/g, "\n"), "utf8").digest("hex") : void 0;
       if (h !== hash)
         out.add(file);
     }
@@ -6086,6 +6202,7 @@ export {
   focusTerms,
   trimSources,
   sinceReview,
+  LENS_BATCH_AGENT,
   lensAgent,
   catalogSlice,
   lensAnswerProblem,
@@ -6109,7 +6226,9 @@ export {
   lensRunOf,
   waitingLenses,
   completeLensRun,
+  completeLensBatch,
   failLens,
   act,
+  editedByPerson,
   overrideStats
 };

package/dist/{chunk-KCF7TFOE.js → chunk-K6JB6XTX.js}

@@ -5,10 +5,10 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   loadCatalog
-} from "./chunk-WWPC2AZ2.js";
+} from "./chunk-5QUOPNLN.js";
 import {
   repoFor
-} from "./chunk-LGDW4G73.js";
+} from "./chunk-TGVVUKTG.js";
 import {
   checkDraft,
   checkFrameworkDraft,
@@ -22,25 +22,25 @@ import {
   proposalYaml,
   reviewRepo,
   surveyRepo
-} from "./chunk-G5BYKJIM.js";
+} from "./chunk-P2VBXX7N.js";
+import {
+  offerCodeDir
+} from "./chunk-ZOSD4FXV.js";
 import {
   matchRepoType
-} from "./chunk-EZBAS5BL.js";
+} from "./chunk-4SLBCEPD.js";
 import {
   modelCovers,
   repoImports,
   runDialectTests,
   runFrameworkTests
-} from "./chunk-RBXDHCN7.js";
-import {
-  offerCodeDir
-} from "./chunk-JZOOX3PQ.js";
+} from "./chunk-TWQRPM76.js";
 import {
   baseClonePath
-} from "./chunk-ZQC7MNQB.js";
+} from "./chunk-XOL3GFW2.js";
 import {
   fsRepo
-} from "./chunk-TLDL2ZZI.js";
+} from "./chunk-7AB6OWTV.js";
 import {
   Dialect,
   FrameworkModel,
@@ -52,7 +52,7 @@ import {
   raiseQuestions,
   require_dist,
   reusedLine
-} from "./chunk-YK6CSODO.js";
+} from "./chunk-PAINMSID.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-LFIIX4OV.js → chunk-KDAHXQIE.js}

@@ -6,41 +6,46 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   claimOf,
   factLabel
-} from "./chunk-7S6VJ643.js";
+} from "./chunk-QOOEYDNJ.js";
+import "./chunk-HK3VOHIE.js";
 import {
-  verifyInputsOf
-} from "./chunk-BAT4CBB7.js";
-import "./chunk-5NLJH6R4.js";
-import "./chunk-QKMDT7VU.js";
-import "./chunk-4W7FOGAB.js";
-import "./chunk-Q2X4IREC.js";
+  safeMessage
+} from "./chunk-THN26IEF.js";
 import {
-  checkoutOf
-} from "./chunk-AB5E5HCN.js";
-import "./chunk-LGDW4G73.js";
+  verifyInputsOf
+} from "./chunk-LN77DXBM.js";
+import "./chunk-L4CESDPB.js";
+import "./chunk-U3NBK4EU.js";
+import "./chunk-455SYIIE.js";
 import {
   repoContractsOf
-} from "./chunk-RUOGHYSK.js";
-import "./chunk-BAXM3JFQ.js";
-import "./chunk-VEJYZEPC.js";
-import "./chunk-IOW6BF3U.js";
-import "./chunk-43E6XX67.js";
-import "./chunk-V3UEPUHT.js";
-import "./chunk-EZBAS5BL.js";
-import "./chunk-KCQS52TH.js";
+} from "./chunk-LPV6T362.js";
+import "./chunk-GIFMBCTW.js";
+import "./chunk-MD7KUEJ3.js";
+import {
+  checkoutOf
+} from "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
+import "./chunk-3AQ2R5NL.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
 import {
   dirSource,
   repairFormSlips,
   verifyFacts
-} from "./chunk-IPSFMTK2.js";
-import "./chunk-TNCROWPQ.js";
-import "./chunk-7IM4BVVH.js";
-import "./chunk-RBXDHCN7.js";
-import "./chunk-YXUIUOQZ.js";
-import "./chunk-CYX36GKZ.js";
-import "./chunk-ZQC7MNQB.js";
-import "./chunk-TLDL2ZZI.js";
-import "./chunk-QNMLLYTN.js";
+} from "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-API5TOUB.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
 import {
   factsDirOf,
   factsRelOf,
@@ -50,14 +55,15 @@ import {
   mapDirOf,
   mapRelOf,
   orgPackDirOf,
+  pairsFromCorrections,
   parseFactsLines,
   questionsRelOf,
   recordPath,
   require_dist,
   specRelOf,
   stackHelpersOff
-} from "./chunk-YK6CSODO.js";
-import "./chunk-MMB2OHUY.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -92,7 +98,7 @@ function editedFields(was, now) {
 }
 function stepsOf(root, repo, o) {
   const branch = `correct/${slugPart(repo)}${o.fact ? `-${slugPart(o.fact)}` : ""}`;
-  const message = o.fact ? `${repo}: a person's correction of ${o.fact}, applied by atticus verify --write` : `${repo}: a person's corrections, applied by atticus verify --write`;
+  const message = safeMessage(o.fact ? `${repo}: a correction by a person of ${o.fact}, applied by atticus verify --write` : `${repo}: corrections by a person, applied by atticus verify --write`);
   const pr = prCommand(o.host, branch);
   return {
     branch,
@@ -129,7 +135,11 @@ async function verifyWritePreview(root, repo, o = {}) {
   const plain = (files2, unavailable) => ({
     repo,
     wrote,
-    ...stepsOf(root, repo, { ...o, ...host ? { host } : {}, files: files2 }),
+    ...stepsOf(root, repo, {
+      ...o.fact ? { fact: o.fact } : {},
+      ...host ? { host } : {},
+      files: files2
+    }),
     ...unavailable ? { unavailable } : {}
   });
   const read = parseFactsLines(text);
@@ -150,11 +160,12 @@ async function verifyWritePreview(root, repo, o = {}) {
     ...off.has("derived-names") ? { derivedNames: false } : {},
     ...off.has("readers") ? { readers: false } : {},
     exclude: inputs.exclude,
-    corrections: inputs.corrections.corrections,
+    corrections: [...inputs.corrections.corrections, ...o.extra ?? []],
     reviewed: inputs.reviewed.entries,
     ...inputs.estate ? { estate: inputs.estate } : {},
     conventions: inputs.conventions,
     notes: inputs.notes,
+    componentTypes: inputs.componentTypes,
     notReached: inputs.notReached
   });
   const kept = new Map(report.accepted.map((f) => [f.id, f]));
@@ -193,7 +204,7 @@ async function verifyWritePreview(root, repo, o = {}) {
       }
     };
   }
-  const { projectFactsIntoCatalog } = await import("./chunk-L4MHJG3I.js");
+  const { projectFactsIntoCatalog } = await import("./chunk-MZGRDONP.js");
   const contracts = await repoContractsOf(root, repo, dir, report.accepted);
   const companion = join(factsDirOf(root), `${repo}.contracts.yaml`);
   const onDisk = await readFile(companion, "utf8").catch(() => void 0);
@@ -203,7 +214,8 @@ async function verifyWritePreview(root, repo, o = {}) {
   const p = await projectFactsIntoCatalog(root, repo, report.accepted, {
     ...op ? { op } : {},
     contracts,
-    cache: false
+    cache: false,
+    ...o.extra?.length ? { extraPairs: pairsFromCorrections(report.accepted, o.extra) } : {}
   });
   const catalogRel = layoutOf(root).catalog.replace(/\/+$/, "");
   const recordFiles = [

package/dist/chunk-KYZMRSPS.js

@@ -0,0 +1,93 @@
+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 {
+  QUESTION_ROLES,
+  changesDirOf,
+  orgPackDirOf,
+  require_dist,
+  roleOfQuestion,
+  roleOfStep,
+  rolesOfPerson
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/change-roles.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var STAGE_FILES = ["feature", "architecture", "stories", "small"];
+var yamlOf = async (path) => {
+  const text = await readFile(path, "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  try {
+    return (0, import_yaml.parse)(text);
+  } catch {
+    return void 0;
+  }
+};
+async function stageQuestions(root, only) {
+  const out = /* @__PURE__ */ new Map();
+  const changes = only ? [only] : await readdir(changesDirOf(root), { withFileTypes: true }).then((d) => d.filter((x) => x.isDirectory()).map((x) => x.name), () => []);
+  for (const change of changes.sort())
+    for (const stage of STAGE_FILES) {
+      const y = await yamlOf(join(changesDirOf(root), change, "stage", `${stage}.yaml`));
+      const ids = Array.isArray(y?.questions) ? y.questions : [];
+      for (const id of ids)
+        if (typeof id === "string" && !out.has(id))
+          out.set(id, { change, role: roleOfStep(`change-${stage}`) });
+    }
+  return out;
+}
+function roleWithStage(q, stages) {
+  return roleOfQuestion(q) ?? stages.get(q.id)?.role;
+}
+function isChangeQuestion(q, change, o) {
+  return q.repo === change || o.stages.get(q.id)?.change === change || !!o.restsOn?.includes(change);
+}
+async function customRoles(root) {
+  const y = await yamlOf(join(orgPackDirOf(root), "roles.yaml"));
+  if (!Array.isArray(y?.custom))
+    return [];
+  return y.custom.flatMap((c) => {
+    const x = c;
+    return typeof x?.id === "string" && typeof x.basedOn === "string" ? [{ id: x.id, basedOn: x.basedOn }] : [];
+  });
+}
+async function personsRoles(root, change, handle) {
+  if (!handle)
+    return [];
+  const y = await yamlOf(join(changesDirOf(root), change, "change.yaml"));
+  const owners = y?.owners;
+  if (!owners || typeof owners !== "object" || Array.isArray(owners))
+    return [];
+  const lists = {};
+  for (const [k, v] of Object.entries(owners))
+    if (Array.isArray(v))
+      lists[k] = v.filter((h) => typeof h === "string");
+  return rolesOfPerson(handle, lists, await customRoles(root));
+}
+function countByRole(questions, roleOf) {
+  const out = {};
+  for (const r of QUESTION_ROLES) {
+    const of = questions.filter((q) => roleOf(q) === r);
+    if (!of.length)
+      continue;
+    const k = (s) => of.filter((q) => q.state === s).length;
+    out[r] = { open: k("open"), answered: k("answered"), retired: k("retired"), total: of.length };
+  }
+  return out;
+}
+export {
+  countByRole,
+  isChangeQuestion,
+  personsRoles,
+  roleWithStage,
+  stageQuestions
+};

package/dist/chunk-L4CESDPB.js

@@ -0,0 +1,22 @@
+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 {
+  effectiveComponentTypes,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-PAINMSID.js";
+
+// packages/cli/dist/component-types.js
+async function componentTypesAt(root, given) {
+  const op = given ?? await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  return effectiveComponentTypes(op?.componentTypes ?? []);
+}
+var componentTypeIds = (types) => new Set(types.map((t) => t.id));
+
+export {
+  componentTypesAt,
+  componentTypeIds
+};