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

package/dist/chunk-UYLBRRFK.js

@@ -0,0 +1,1106 @@
+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 {
+  safeMessage,
+  withFileLock
+} from "./chunk-THN26IEF.js";
+import {
+  checkoutOf
+} from "./chunk-Q46QDDMF.js";
+import {
+  AI_LINE_BY,
+  AnswerMatch,
+  FactCorrection,
+  HOSTS_NONE,
+  JOINED_BY_AI,
+  JOINED_BY_ANSWER,
+  JOINED_BY_PERSON,
+  Question,
+  QuestionError,
+  RULE_AFTER_CORRECTIONS,
+  TARGETS_STEP_ID,
+  aiPause,
+  answerByWords,
+  answerQuestion,
+  auditPrecision,
+  batchRelOf,
+  callsOfQuestion,
+  catalogDirOf,
+  checkedProposals,
+  correctionLine,
+  decideOf,
+  deriveMatch,
+  factsDirOf,
+  factsRelOf,
+  isAiBy,
+  linkCandidates,
+  linksFor,
+  listBatches,
+  listQuestions,
+  loadOrgPack,
+  matchCovers,
+  newBatchId,
+  orgPackDirOf,
+  pairingBar,
+  parseAuditFile,
+  parseCorrections,
+  parseFacts,
+  proposalRelOf,
+  questionAiProblem,
+  questionBar,
+  questionsRelOf,
+  readBatch,
+  readQuestion,
+  ruleKindOf,
+  writeBatch,
+  writeQuestion
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.js";
+
+// packages/cli/dist/ai-decide.js
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+var DecideError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var inAcpSession = (env = process.env) => !!env.ATTICUS_ACP_SESSION;
+var AI_RUNTIME = "copilot-acp";
+async function factsOf(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => "");
+  if (!text.trim())
+    return [];
+  const r = parseFacts(text);
+  return r.ok ? r.facts : [];
+}
+var correctionsFile = (root, repo) => join(factsDirOf(root), `${repo}.corrections.jsonl`);
+var correctionsRel = (root, repo) => `${factsRelOf(root)}/${repo}.corrections.jsonl`;
+async function correctionsOf(root, repo) {
+  const text = await readFile(correctionsFile(root, repo), "utf8").catch(() => "");
+  return parseCorrections(text).corrections;
+}
+async function correctedRepos(root) {
+  return (await readdir(factsDirOf(root)).catch(() => [])).filter((n) => n.endsWith(".corrections.jsonl")).map((n) => n.slice(0, -".corrections.jsonl".length)).sort();
+}
+async function rewriteCorrections(root, repo, o) {
+  const file = correctionsFile(root, repo);
+  return withFileLock(file, async () => {
+    const text = await readFile(file, "utf8").catch(() => "");
+    const eol = /\r\n/.test(text) ? "\r\n" : "\n";
+    const lines = text.split(/\r?\n/).filter((l, i, all) => l !== "" || i < all.length - 1);
+    let removed = 0;
+    const gone = new Set((o.remove ?? []).map((l) => l.trim()));
+    const kept = lines.filter((l) => {
+      if (l.trim() && gone.has(l.trim())) {
+        gone.delete(l.trim());
+        removed++;
+        return false;
+      }
+      return true;
+    });
+    const have = new Set(kept.map((l) => l.trim()));
+    const wanted = o.pick ? o.pick(parseCorrections(text).corrections) : o.add ?? [];
+    const add = wanted.filter((l) => !have.has(l.trim()));
+    const out = [...kept.filter((l) => l.trim() !== ""), ...add];
+    if (!removed && !add.length)
+      return { removed: 0, added: 0, ...o.pick ? { picked: [] } : {} };
+    await writeFileAtomic(file, out.length ? out.join(eol) + eol : "");
+    return { removed, added: add.length, ...o.pick ? { picked: add } : {} };
+  });
+}
+var callLikeOf = (c) => ({
+  kind: "call",
+  id: c.fact,
+  cite: { file: c.target.file, line: c.target.line, value: c.target.value }
+});
+function standingAi(corrections) {
+  return corrections.filter((c) => c.ai && linksFor(callLikeOf(c), corrections)[0] === c);
+}
+function subjectOfCall(f) {
+  if (f.callType === "event-topic" || f.callType === "mq-queue")
+    return { topic: f.path };
+  if (f.path?.startsWith("/"))
+    return { path: f.path };
+  return void 0;
+}
+async function coversCall(match, f, facts) {
+  const s = subjectOfCall(f);
+  if (s?.topic)
+    return matchCovers(match, s);
+  const { ruleCoversCall } = await import("./chunk-BXZ4PKIT.js");
+  return ruleCoversCall(match, f, facts);
+}
+async function aiAuditItems(root) {
+  const out = [];
+  for (const n of (await readdir(factsDirOf(root)).catch(() => [])).sort()) {
+    if (!n.endsWith(".audit.yaml"))
+      continue;
+    const r = parseAuditFile(await readFile(join(factsDirOf(root), n), "utf8").catch(() => ""));
+    if (r.ok)
+      out.push(...r.file.items.filter((i) => i.kind === "ai"));
+  }
+  return out;
+}
+async function decideState(root) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const configured = decideOf(op.runtime);
+  const precision = auditPrecision(await aiAuditItems(root)).ai;
+  return {
+    configured,
+    now: aiPause(configured, precision),
+    precision,
+    decideIn: decideIn(op.runtime)
+  };
+}
+function decideIn(rt) {
+  if (rt.ai === "off")
+    return [];
+  const out = [];
+  if (rt.modes.allowed.includes("copilot-acp") && rt.assistants.allowed.includes("copilot"))
+    out.push("copilot-acp");
+  if (rt.modes.allowed.includes("hand-off"))
+    out.push("hand-off");
+  return out;
+}
+var notHere = (runtime, state) => runtime === "hand-off" && !state.decideIn.includes("hand-off") ? "runtime.yaml doesn't allow hand-off here (modes.allowed): a person confirms it" : void 0;
+async function pairingCitesProblem(root, repos, lines) {
+  if (!lines.length)
+    return "it names no line it rests on";
+  const dirs = [];
+  for (const r of repos) {
+    const d = await checkoutOf(root, r).catch(() => void 0);
+    if (d)
+      dirs.push(d);
+  }
+  if (!dirs.length)
+    return "no checkout of either repo is here to check its lines";
+  for (const l of lines) {
+    const m = /^(.+):(\d+)$/.exec(l);
+    if (!m)
+      return `${l} isn't a path:line`;
+    const rel = m[1].replace(/\\/g, "/").replace(/^\.\//, "");
+    if (isAbsolute(rel) || rel.split("/").includes(".."))
+      return `${l} leaves the repo`;
+    let found = false;
+    for (const d of dirs) {
+      const file = resolve(d, rel);
+      const back = relative(d, file);
+      if (!back || back.startsWith("..") || isAbsolute(back))
+        continue;
+      const ok = await stat(file).then((s) => s.isFile(), () => false);
+      if (!ok)
+        continue;
+      const text = (await readFile(file, "utf8").catch(() => "")).split(/\r?\n/);
+      if ((text[Number(m[2]) - 1] ?? "").trim())
+        found = true;
+    }
+    if (!found)
+      return `${l} isn't a line with words on it in either checkout`;
+  }
+  return void 0;
+}
+async function linkRulesOf(root, repo) {
+  return (await listBatches(root)).batches.filter((b) => b.kind === "rule" && !b.undone && !!b.correction?.rule && b.correction.item.startsWith(`link:${repo}:`)).map((b) => ({ match: b.correction.rule.match, answer: b.correction.answer, batch: b.id }));
+}
+async function decideLinks(root, o) {
+  if (inAcpSession(o.env) || !o.proposals.length)
+    return void 0;
+  const state = await decideState(root);
+  if (state.configured.links === "propose")
+    return void 0;
+  const runtime = o.runtime ?? AI_RUNTIME;
+  const kept = [];
+  const off = notHere(runtime, state);
+  if (off) {
+    for (const p of o.proposals)
+      kept.push({ call: p.call, api: p.api, why: off });
+    return { mode: "propose", applied: [], kept };
+  }
+  const paused = state.now.paused?.why;
+  if (state.now.links === "propose") {
+    for (const p of o.proposals)
+      kept.push({ call: p.call, api: p.api, why: "deciding is paused: a person confirms it" });
+    return { mode: "propose", applied: [], kept, ...paused ? { paused } : {} };
+  }
+  const to = o.view.to.repo;
+  if (!to) {
+    for (const p of o.proposals)
+      kept.push({
+        call: p.call,
+        api: p.api,
+        why: "the AI pairs only with a repo's entry: a pairing with an outside system is a person's"
+      });
+    return { mode: "auto", applied: [], kept };
+  }
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const batch = newBatchId(o.now ?? /* @__PURE__ */ new Date());
+  const rules = await linkRulesOf(root, o.view.from);
+  const applied = [];
+  const lines = [];
+  const items = [];
+  const calls = /* @__PURE__ */ new Map();
+  for (const p of o.proposals) {
+    const call = o.view.calls.find((c) => c.fact === p.call && c.status !== "paired");
+    const f = o.facts.find((x) => x.id === p.call && x.kind === "call");
+    const api = o.view.apis.find((a) => a.id === p.api && a.kind !== "operation");
+    if (!call || !f || !api) {
+      kept.push({ call: p.call, api: p.api, why: "the call or the API isn't on record as loose" });
+      continue;
+    }
+    let ruleAgrees = false;
+    let against;
+    for (const r2 of rules)
+      if (await coversCall(r2.match, f, o.facts)) {
+        if (r2.answer === to)
+          ruleAgrees = true;
+        else
+          against = r2;
+        break;
+      }
+    if (against) {
+      kept.push({
+        call: p.call,
+        api: p.api,
+        why: `a person's rule (${against.match}) says these calls go to ${against.answer}`
+      });
+      continue;
+    }
+    const cites = await pairingCitesProblem(root, [o.view.from, to], p.lines);
+    if (cites) {
+      kept.push({ call: p.call, api: p.api, why: `the citation check fails: ${cites}` });
+      continue;
+    }
+    const bar = pairingBar(call, p.api, { ruleAgrees });
+    if (!bar) {
+      kept.push({
+        call: p.call,
+        api: p.api,
+        why: "the shapes don't rank that API first and no person's rule says so: a person confirms it"
+      });
+      continue;
+    }
+    const line = correctionLine(FactCorrection.parse({
+      schemaVersion: 2,
+      fact: f.id,
+      target: { kind: "call", file: f.cite.file, line: f.cite.line, value: f.cite.value },
+      action: "link",
+      link: {
+        repo: to,
+        entry: api.id,
+        ...api.method ? { method: api.method } : {},
+        path: api.path
+      },
+      by: AI_LINE_BY,
+      at,
+      ai: { runtime, run: o.run, bar },
+      batch
+    }));
+    lines.push(line);
+    items.push({ kind: "link", repo: o.view.from, fact: f.id, line });
+    applied.push({ call: p.call, api: p.api, bar });
+    calls.set(line, f);
+  }
+  if (!lines.length)
+    return { mode: "auto", applied, kept };
+  const r = await rewriteCorrections(root, o.view.from, {
+    pick: (now) => lines.filter((l) => {
+      const f = calls.get(l);
+      return !linksFor(f, now).some((c) => !c.ai);
+    })
+  });
+  const written = new Set(r.picked ?? []);
+  for (let i = applied.length - 1; i >= 0; i--) {
+    if (written.has(lines[i]))
+      continue;
+    kept.push({
+      call: applied[i].call,
+      api: applied[i].api,
+      why: "a person has said where this call goes: their word stands"
+    });
+    applied.splice(i, 1);
+    items.splice(i, 1);
+  }
+  if (!applied.length)
+    return { mode: "auto", applied, kept };
+  await writeBatch(root, {
+    schema: 1,
+    id: batch,
+    kind: "ai",
+    at,
+    by: { kind: "ai", runtime, run: o.run },
+    applied: items,
+    reverted: []
+  });
+  return { mode: "auto", batch, applied, kept };
+}
+async function proposalsSnapshot(root) {
+  const out = /* @__PURE__ */ new Map();
+  for (const p of await checkedProposals(root)) {
+    const text = await readFile(join(root, ...p.file.split("/")), "utf8").catch(() => void 0);
+    if (text !== void 0)
+      out.set(p.id, text);
+  }
+  return out;
+}
+async function targetRuleVerdict(root, q, label, questions) {
+  const facts = await factsOf(root, q.repo);
+  const calls = callsOfQuestion(q, /* @__PURE__ */ new Map([[q.repo, facts]]));
+  if (!calls.length)
+    return void 0;
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const { estateRepos, ruledTargets } = await import("./chunk-BXZ4PKIT.js");
+  const repoType = estateRepos(op).find((r) => r.id === q.repo)?.type;
+  const ruled = ruledTargets(q.repo, facts, questions, repoType ? { repoType } : {});
+  const labels = calls.map((c) => ruled.get(c.id)?.label);
+  if (labels.some((l) => l !== void 0 && l !== label))
+    return "against";
+  return labels.every((l) => l === label) ? "agrees" : void 0;
+}
+async function decideAnswers(root, o) {
+  if (inAcpSession(o.env))
+    return void 0;
+  const state = await decideState(root);
+  if (state.configured.questions === "propose")
+    return void 0;
+  const runtime = o.runtime ?? AI_RUNTIME;
+  const proposals = (await checkedProposals(root)).filter((p) => p.ok && p.proposal && (!o.ids || o.ids.has(p.id)));
+  const kept = [];
+  const off = notHere(runtime, state);
+  if (off) {
+    for (const p of proposals)
+      kept.push({ id: p.id, why: off });
+    return { mode: "propose", applied: [], kept };
+  }
+  if (state.now.questions === "propose") {
+    for (const p of proposals)
+      kept.push({ id: p.id, why: "deciding is paused: a person confirms it" });
+    return {
+      mode: "propose",
+      applied: [],
+      kept,
+      ...state.now.paused ? { paused: state.now.paused.why } : {}
+    };
+  }
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const batch = newBatchId(o.now ?? /* @__PURE__ */ new Date());
+  const everyTarget = (await listQuestions(root, { step: TARGETS_STEP_ID })).questions;
+  const applied = [];
+  const items = [];
+  for (const p of proposals) {
+    const q = await readQuestion(root, p.id).catch(() => void 0);
+    const option = p.proposal.answer.option;
+    if (!q)
+      continue;
+    const problem = questionAiProblem(q, option);
+    if (problem) {
+      kept.push({ id: p.id, why: problem });
+      continue;
+    }
+    const label = q.options[option - 1].label;
+    const { TARGETS_NO_EVIDENCE } = await import("./chunk-BXZ4PKIT.js");
+    const shapesFirst = option === 1 && !q.options[0].means.includes(TARGETS_NO_EVIDENCE);
+    const rule = await targetRuleVerdict(root, q, label, everyTarget);
+    if (rule === "against") {
+      kept.push({ id: p.id, why: "a person's rule covers its calls and says otherwise" });
+      continue;
+    }
+    const bar = questionBar(q, option, { shapesFirst, ruleAgrees: rule === "agrees" });
+    if (!bar) {
+      kept.push({
+        id: p.id,
+        why: "the shapes don't list that option first and no person's rule says so: a person confirms it"
+      });
+      continue;
+    }
+    const by = { kind: "ai", runtime, run: o.run, bar };
+    try {
+      await answerQuestion(root, q.id, {
+        option,
+        by,
+        at,
+        batch,
+        proposal: { by: p.proposal.by, at: p.proposal.at, cites: p.proposal.cites }
+      });
+    } catch (e) {
+      if (e instanceof QuestionError) {
+        kept.push({ id: p.id, why: e.message });
+        continue;
+      }
+      throw e;
+    }
+    await rm(join(root, ...proposalRelOf(root, q.id).split("/")), { force: true });
+    items.push({ kind: "question", id: q.id });
+    applied.push({ id: q.id, option, bar });
+  }
+  if (items.length)
+    await writeBatch(root, {
+      schema: 1,
+      id: batch,
+      kind: "ai",
+      at,
+      by: { kind: "ai", runtime, run: o.run },
+      applied: items,
+      reverted: []
+    });
+  return { mode: "auto", ...items.length ? { batch } : {}, applied, kept };
+}
+async function decisionsView(root) {
+  const state = await decideState(root);
+  const linkItems = [];
+  const lines = { byAi: 0, byPerson: 0 };
+  for (const repo of await correctedRepos(root)) {
+    const all = await correctionsOf(root, repo);
+    for (const c of all)
+      if (c.action === "link" && c.link && linksFor(callLikeOf(c), all)[0] === c) {
+        if (c.ai)
+          lines.byAi++;
+        else
+          lines.byPerson++;
+      }
+    for (const c of standingAi(all)) {
+      linkItems.push({
+        kind: "link",
+        item: `link:${repo}:${c.fact}`,
+        repo,
+        what: `${repo}'s call ${c.target.value} (${c.target.file}:${c.target.line}) \u2192 ${[c.link.method, c.link.path].filter(Boolean).join(" ")} on ${c.link.repo}`,
+        decided: c.link.entry ?? `${c.link.method ?? ""} ${c.link.path}`.trim(),
+        call: { fact: c.fact, file: c.target.file, line: c.target.line, value: c.target.value },
+        to: {
+          repo: c.link.repo,
+          ...c.link.entry ? { entry: c.link.entry } : {},
+          ...c.link.method ? { method: c.link.method } : {},
+          path: c.link.path
+        },
+        runtime: c.ai.runtime,
+        run: c.ai.run,
+        ...c.ai.bar ? { bar: c.ai.bar } : {},
+        ...c.batch ? { batch: c.batch } : {},
+        at: c.at,
+        cites: [`${repo} ${c.target.file}:${c.target.line}`]
+      });
+    }
+  }
+  const qs = (await listQuestions(root)).questions;
+  const questionItems = [];
+  const qCounts = { fromCode: 0, byPerson: 0, byAi: 0, open: 0, retired: 0 };
+  for (const q of qs) {
+    if (q.state === "open")
+      qCounts.open++;
+    else if (q.state === "retired")
+      qCounts.retired++;
+    else if (q.answer && isAiBy(q.answer.by)) {
+      qCounts.byAi++;
+      const option = q.answer.option ?? 0;
+      questionItems.push({
+        kind: "question",
+        item: q.id,
+        repo: q.repo,
+        what: `${q.question.trim()} AI: ${q.options[option - 1]?.label ?? ""}`,
+        decided: q.options[option - 1]?.label ?? "",
+        question: { text: q.question, option, options: q.options.map((x) => x.label) },
+        runtime: q.answer.by.runtime,
+        run: q.answer.by.run,
+        ...q.answer.by.bar ? { bar: q.answer.by.bar } : {},
+        ...q.answer.batch ? { batch: q.answer.batch } : {},
+        at: q.answer.at,
+        cites: (q.answer.proposal?.cites ?? []).map((c) => `${c.repo ?? q.repo} ${c.file}:${c.line}`)
+      });
+    } else
+      qCounts.byPerson++;
+  }
+  const linkCounts = { fromCode: 0, byPerson: 0, byAi: 0 };
+  const { readCatalog } = await import("./chunk-BXZ4PKIT.js");
+  const cat = await readCatalog(join(catalogDirOf(root), "generated")).catch(() => void 0);
+  for (const r of cat?.records ?? []) {
+    if (r.kind !== "Interface")
+      continue;
+    const flags = r.flags ?? [];
+    if (flags.includes(JOINED_BY_AI))
+      linkCounts.byAi++;
+    else if (flags.includes(JOINED_BY_PERSON) || flags.includes(JOINED_BY_ANSWER))
+      linkCounts.byPerson++;
+    else
+      linkCounts.fromCode++;
+  }
+  const { batches, problems } = await listBatches(root);
+  return {
+    decide: {
+      configured: state.configured,
+      now: { links: state.now.links, questions: state.now.questions },
+      ...state.now.paused ? { paused: state.now.paused } : {},
+      precision: state.precision,
+      decideIn: state.decideIn
+    },
+    links: { counts: linkCounts, items: linkItems, lines },
+    questions: { counts: qCounts, items: questionItems },
+    batches: batches.map((b) => batchView(root, b)),
+    problems
+  };
+}
+function batchView(root, b) {
+  return {
+    id: b.id,
+    kind: b.kind,
+    at: b.at,
+    by: answerByWords(b.by),
+    ...isAiBy(b.by) ? { run: b.by.run } : b.correction?.run ? { run: b.correction.run } : {},
+    applied: b.applied.length,
+    reverted: b.reverted.length,
+    ...b.correction ? {
+      correction: {
+        item: b.correction.item,
+        answer: b.correction.answer,
+        ...b.correction.rule ? {
+          rule: {
+            kind: b.correction.rule.kind,
+            match: b.correction.rule.match,
+            from: b.correction.rule.from
+          }
+        } : {}
+      }
+    } : {},
+    ...b.undone ? { undone: b.undone } : {},
+    file: batchRelOf(root, b.id)
+  };
+}
+var counted = (spread) => ({
+  applied: spread.filter((s) => s.change === "applied").length,
+  confirmed: spread.filter((s) => s.change === "confirmed").length,
+  replaced: spread.filter((s) => s.change === "replaced").length,
+  reverted: spread.filter((s) => s.change === "reverted").length
+});
+async function shapeCount(root, shape) {
+  return (await listBatches(root)).batches.filter((b) => b.kind === "rule" && !b.undone && b.correction?.shape === shape).length + 1;
+}
+async function correctDecision(root, req, o) {
+  if (inAcpSession(o.env))
+    throw new DecideError("refused", "A correction is a person's: a Copilot session acts as no one (ADR 0171, round 32).");
+  return req.item.startsWith("link:") ? correctLink(root, req, o) : correctQuestion(root, req, o);
+}
+async function correctQuestion(root, req, o) {
+  const q = await readQuestion(root, req.item).catch(() => void 0);
+  if (!q)
+    throw new DecideError("not-found", `There is no question ${req.item}.`);
+  if (!q.answer || !isAiBy(q.answer.by))
+    throw new DecideError("conflict", `${q.id} isn't an AI decision: answer it as usual (atticus questions answer ${q.id}).`);
+  const aiBy = q.answer.by;
+  const option = req.none ? q.options.findIndex((x) => x.label === HOSTS_NONE) + 1 : req.option ?? 0;
+  if (!option || option > q.options.length)
+    throw new DecideError("bad", req.none ? `${q.id} has no "None of these" option: pick one of its ${q.options.length} options.` : `Pick one of ${q.id}'s ${q.options.length} options (from 1), or none.`);
+  const label = q.options[option - 1].label;
+  const aiLabel = q.options[(q.answer.option ?? 0) - 1]?.label ?? "";
+  const facts = await factsOf(root, q.repo);
+  const byRepo = /* @__PURE__ */ new Map([[q.repo, facts]]);
+  const calls = callsOfQuestion(q, byRepo);
+  const everyTarget = (await listQuestions(root, { step: TARGETS_STEP_ID })).questions;
+  const similar = req.similar !== false;
+  let rule;
+  let noRule;
+  if (similar) {
+    if (req.match) {
+      if (!AnswerMatch.safeParse(req.match).success || ruleKindOf(req.match) === "topic")
+        throw new DecideError("bad", `${req.match} isn't a rule a targets answer takes: a path prefix (/forge/limits/**) or a host pattern (*.payments.forge.internal).`);
+      rule = { kind: ruleKindOf(req.match), match: req.match, derived: false };
+    } else {
+      const subject = calls.map((c) => subjectOfCall(c)).find((s) => s?.path);
+      const siblings = everyTarget.filter((x) => x.id !== q.id && x.repo === q.repo && x.state === "answered" && x.answer && isAiBy(x.answer.by) && x.options[(x.answer.option ?? 0) - 1]?.label === aiLabel).flatMap((x) => callsOfQuestion(x, byRepo)).map((c) => subjectOfCall(c)).filter((s) => !!s?.path);
+      if (!subject)
+        noRule = "its calls have no path a rule can name: give one with match";
+      else {
+        const d = deriveMatch(subject, siblings);
+        if (d.match === "/**")
+          noRule = "the calls share no path narrower than every path: give a rule with match, or correct it alone";
+        else if (!AnswerMatch.safeParse(d.match).success)
+          noRule = `${d.match} isn't a rule a targets answer takes: give one with match`;
+        else
+          rule = { ...d, derived: true };
+      }
+    }
+  }
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const batch = newBatchId(o.now ?? /* @__PURE__ */ new Date());
+  const plans = [];
+  if (rule) {
+    for (const x of everyTarget) {
+      if (x.id === q.id || x.repo !== q.repo || x.scope.level !== "repo")
+        continue;
+      const ai = x.state === "answered" && x.answer && isAiBy(x.answer.by);
+      if (x.state !== "open" && !ai)
+        continue;
+      const xc = callsOfQuestion(x, byRepo);
+      if (!xc.length)
+        continue;
+      let all = true;
+      for (const c of xc)
+        if (!await coversCall(rule.match, c, facts))
+          all = false;
+      if (!all)
+        continue;
+      const idx = x.options.findIndex((y) => y.label === label);
+      const was = ai ? x.options[(x.answer.option ?? 0) - 1]?.label : void 0;
+      const what = x.question.trim();
+      if (idx >= 0) {
+        const change = !ai ? "applied" : was === label ? "confirmed" : "replaced";
+        plans.push({
+          view: {
+            item: x.id,
+            repo: x.repo,
+            what,
+            ...was ? { was } : {},
+            now: label,
+            change
+          },
+          applied: { kind: "question", id: x.id, ...x.answer ? { before: x.answer } : {} },
+          write: async () => {
+            await answerQuestion(root, x.id, {
+              option: idx + 1,
+              by: o.by,
+              at,
+              batch,
+              rule: { from: q.id, match: rule.match }
+            });
+          }
+        });
+      } else if (ai)
+        plans.push({
+          view: { item: x.id, repo: x.repo, what, ...was ? { was } : {}, change: "reverted" },
+          reverted: { kind: "question", id: x.id, before: x.answer },
+          write: async () => {
+            const { answer: _a, ...rest } = x;
+            await writeQuestion(root, Question.parse({ ...rest, state: "open" }));
+          }
+        });
+    }
+  }
+  const spread = plans.map((p) => p.view);
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const { estateRepos } = await import("./chunk-BXZ4PKIT.js");
+  const repoType = estateRepos(op).find((r) => r.id === q.repo)?.type;
+  const shape = `question:${repoType ?? q.repo}:${rule?.match ?? calls[0]?.path ?? q.id}`;
+  const n = await shapeCount(root, shape);
+  const files = [`${questionsRelOf(root)}/`, ...req.preview ? [] : [batchRelOf(root, batch)]];
+  const result = {
+    written: !req.preview,
+    ...req.preview ? {} : { batch },
+    item: q.id,
+    answer: label,
+    ...rule ? { rule } : {},
+    ...similar && !rule && noRule ? { noRule } : {},
+    spread,
+    counts: counted(spread),
+    ...n >= RULE_AFTER_CORRECTIONS && repoType ? {
+      makeRule: {
+        corrections: n,
+        shape,
+        repo: q.repo,
+        command: `atticus rules draft --repo ${q.repo} --about "calls under ${rule?.match ?? calls[0]?.path ?? "these paths"} go to ${label}"`
+      }
+    } : {},
+    files: [...new Set(files)],
+    verify: [`atticus verify ${q.repo} --write`],
+    commit: `git add ${questionsRelOf(root)}/ ${batchRelOf(root, batch).replace(/\/[^/]+$/, "/")}
+git commit -m "${safeMessage(`${q.repo}: an AI answer corrected${rule ? `, and spread by ${rule.match}` : ""}`)}"`
+  };
+  if (req.preview)
+    return result;
+  const before = q.answer;
+  try {
+    await answerQuestion(root, q.id, {
+      option,
+      by: o.by,
+      at,
+      batch,
+      ...rule ? { match: rule.match } : {}
+    });
+  } catch (e) {
+    if (e instanceof QuestionError)
+      throw new DecideError("bad", e.message);
+    throw e;
+  }
+  for (const p of plans)
+    await p.write();
+  await writeBatch(root, {
+    schema: 1,
+    id: batch,
+    kind: "rule",
+    at,
+    by: o.by,
+    correction: {
+      item: q.id,
+      answer: label,
+      ...rule ? { rule: { from: q.id, match: rule.match, kind: rule.kind } } : {},
+      run: aiBy.run,
+      shape
+    },
+    applied: [
+      { kind: "question", id: q.id, before },
+      ...plans.flatMap((p) => p.applied ? [p.applied] : [])
+    ],
+    reverted: plans.flatMap((p) => p.reverted ? [p.reverted] : [])
+  });
+  return result;
+}
+function parseLinkItem(item) {
+  const m = /^link:([A-Za-z0-9._-]{1,200}):(.+)$/.exec(item);
+  if (!m)
+    throw new DecideError("bad", `${item} isn't link:<repo>:<call fact id> or a question id.`);
+  return { repo: m[1], fact: m[2] };
+}
+async function correctLink(root, req, o) {
+  const { repo, fact } = parseLinkItem(req.item);
+  const facts = await factsOf(root, repo);
+  const f = facts.find((x) => x.id === fact && x.kind === "call");
+  if (!f)
+    throw new DecideError("not-found", `${repo} has no call ${fact} on record.`);
+  const corrections = await correctionsOf(root, repo);
+  const standing = linksFor(f, corrections)[0];
+  if (!standing?.ai || !standing.link?.repo)
+    throw new DecideError("conflict", `${repo}'s call ${fact} isn't paired by AI: correct it on the canvas (Connect to\u2026) as usual.`);
+  const aiRepo = standing.link.repo;
+  const none = req.none === true;
+  if (!none && (!req.api || !req.repo))
+    throw new DecideError("bad", "Say the right API and its repo ({ api, repo }), or none.");
+  const target = none ? void 0 : req.repo;
+  let entry;
+  if (target) {
+    entry = (await factsOf(root, target)).find((x) => x.id === req.api && x.kind === "entry");
+    if (!entry)
+      throw new DecideError("not-found", `${target} has no API ${req.api} on record.`);
+  }
+  const answer = target ?? "none";
+  const similar = req.similar !== false;
+  let rule;
+  let noRule;
+  const standingAll = standingAi(corrections);
+  if (similar) {
+    if (req.match)
+      rule = { kind: ruleKindOf(req.match, subjectOfCall(f)), match: req.match, derived: false };
+    else {
+      const subject = subjectOfCall(f);
+      const siblings = standingAll.filter((c) => c !== standing && c.link?.repo === aiRepo).map((c) => facts.find((x) => x.id === c.fact && x.kind === "call")).flatMap((x) => x ? [subjectOfCall(x)] : []).filter((s) => !!s);
+      if (!subject)
+        noRule = "the call's path is a name, not a path a rule can name: give one with match";
+      else {
+        const d = deriveMatch(subject, siblings);
+        if (d.match === "/**")
+          noRule = "the calls share no path narrower than every path: give a rule with match, or correct it alone";
+        else
+          rule = { ...d, derived: true };
+      }
+    }
+  }
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const batch = newBatchId(o.now ?? /* @__PURE__ */ new Date());
+  const lineFor = (c, api, own) => correctionLine(FactCorrection.parse({
+    schemaVersion: 2,
+    fact: c.id,
+    target: { kind: "call", file: c.cite.file, line: c.cite.line, value: c.cite.value },
+    action: api ? "link" : "unlink",
+    ...api ? {
+      link: {
+        repo: target,
+        entry: api.id,
+        ...api.method ? { method: api.method.toUpperCase() } : {},
+        path: api.path
+      }
+    } : {},
+    by: o.by,
+    at,
+    batch,
+    ...own && rule ? { match: rule.match } : {},
+    ...!own && rule ? { rule: { from: req.item, match: rule.match } } : {}
+  }));
+  const ownLine = lineFor(f, entry ? { id: entry.id, ...entry.method ? { method: entry.method } : {}, path: entry.path } : void 0, true);
+  const spread = [];
+  const add = [ownLine];
+  const remove = [];
+  const appliedItems = [{ kind: "link", repo, fact: f.id, line: ownLine }];
+  const revertedItems = [];
+  if (rule) {
+    const { candidatesOf, settingsOf } = await import("./chunk-PRZ7KMWL.js");
+    const box = { repo: target ?? aiRepo };
+    const cands = box.repo !== repo ? await candidatesOf(root, repo, box).catch(() => void 0) : void 0;
+    const loose = new Set((cands?.view.calls ?? []).filter((c) => c.status !== "paired").map((c) => c.fact));
+    const apis = (cands?.view.apis ?? []).filter((a) => a.kind !== "operation");
+    const settings = settingsOf(facts);
+    const bestOf = (c) => {
+      if (!target || !apis.length)
+        return void 0;
+      const s = linkCandidates({
+        from: repo,
+        facts: [c],
+        join: { joins: [], asks: [], misses: [], outside: [], left: [] },
+        apis,
+        pairs: {},
+        to: { repo: target },
+        settings
+      }).calls[0]?.suggestion?.api;
+      return s ? apis.find((a) => a.id === s) : void 0;
+    };
+    const words = (c) => `${repo}'s call ${[c.method?.toUpperCase(), c.path].filter(Boolean).join(" ")} (${c.cite.file}:${c.cite.line})`;
+    for (const c of facts) {
+      if (c.kind !== "call" || c.id === f.id)
+        continue;
+      if (!await coversCall(rule.match, c, facts))
+        continue;
+      const st = linksFor(c, corrections)[0];
+      if (st && !st.ai)
+        continue;
+      const item = `link:${repo}:${c.id}`;
+      const was = st?.ai ? `${st.link.repo} ${[st.link.method, st.link.path].filter(Boolean).join(" ")}` : void 0;
+      if (!st && !loose.has(c.id))
+        continue;
+      if (!target) {
+        const l = lineFor(c);
+        add.push(l);
+        appliedItems.push({ kind: "link", repo, fact: c.id, line: l });
+        spread.push({
+          item,
+          repo,
+          what: words(c),
+          ...was ? { was } : {},
+          now: "none",
+          change: st ? "replaced" : "applied"
+        });
+        continue;
+      }
+      const same = st?.ai && st.link?.repo === target;
+      const api = same ? {
+        id: st.link.entry ?? "",
+        ...st.link.method ? { method: st.link.method } : {},
+        path: st.link.path
+      } : bestOf(c);
+      if (api && api.id) {
+        const l = lineFor(c, api);
+        add.push(l);
+        appliedItems.push({ kind: "link", repo, fact: c.id, line: l });
+        spread.push({
+          item,
+          repo,
+          what: words(c),
+          ...was ? { was } : {},
+          now: `${target} ${[api.method, api.path].filter(Boolean).join(" ")}`,
+          change: !st ? "applied" : same ? "confirmed" : "replaced"
+        });
+      } else if (st?.ai) {
+        const l = correctionLine(st);
+        remove.push(l);
+        revertedItems.push({ kind: "link", repo, fact: c.id, line: l });
+        spread.push({ item, repo, what: words(c), ...was ? { was } : {}, change: "reverted" });
+      }
+    }
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const { estateRepos } = await import("./chunk-BXZ4PKIT.js");
+  const repoType = estateRepos(op).find((r) => r.id === repo)?.type;
+  const shape = `link:${repoType ?? repo}:${rule?.match ?? f.path}`;
+  const n = await shapeCount(root, shape);
+  const rel = correctionsRel(root, repo);
+  const result = {
+    written: !req.preview,
+    ...req.preview ? {} : { batch },
+    item: req.item,
+    answer: entry ? `${target} ${[entry.method?.toUpperCase(), entry.path].filter(Boolean).join(" ")}` : "none",
+    ...rule ? { rule } : {},
+    ...similar && !rule && noRule ? { noRule } : {},
+    spread,
+    counts: counted(spread),
+    ...n >= RULE_AFTER_CORRECTIONS && repoType && entry ? { makeRule: { corrections: n, shape, repo, line: ownLine } } : {},
+    files: [rel, ...req.preview ? [] : [batchRelOf(root, batch)]],
+    verify: [`atticus verify ${repo} --write`],
+    commit: `git add ${rel} ${batchRelOf(root, batch).replace(/\/[^/]+$/, "/")}
+git commit -m "${safeMessage(`${repo}: an AI pairing corrected${rule ? `, and spread by ${rule.match}` : ""}`)}"`
+  };
+  if (req.preview)
+    return result;
+  await rewriteCorrections(root, repo, { remove, add });
+  await writeBatch(root, {
+    schema: 1,
+    id: batch,
+    kind: "rule",
+    at,
+    by: o.by,
+    correction: {
+      item: req.item,
+      answer,
+      ...rule ? { rule: { from: req.item, match: rule.match, kind: rule.kind } } : {},
+      run: standing.ai.run,
+      shape
+    },
+    applied: appliedItems,
+    reverted: revertedItems
+  });
+  return result;
+}
+async function batchStands(root, b) {
+  for (const i of b.applied) {
+    if (i.kind === "question") {
+      const q = await readQuestion(root, i.id).catch(() => void 0);
+      if (q?.answer?.batch === b.id)
+        return true;
+    } else {
+      const text = await readFile(correctionsFile(root, i.repo), "utf8").catch(() => "");
+      if (text.split(/\r?\n/).some((l) => l.trim() === i.line.trim()))
+        return true;
+    }
+  }
+  return false;
+}
+async function undoBatch(root, id, o) {
+  if (inAcpSession(o.env))
+    throw new DecideError("refused", "Undo is a person's: a Copilot session acts as no one.");
+  const b = await readBatch(root, id);
+  if (!b)
+    throw new DecideError("not-found", `There is no batch ${id}.`);
+  if (b.undone)
+    throw new DecideError("conflict", `${id} was undone by ${b.undone.by} on ${b.undone.at.slice(0, 10)}.`);
+  let removed = 0;
+  let restored = 0;
+  const skipped = [];
+  const files = /* @__PURE__ */ new Set();
+  const repos = /* @__PURE__ */ new Set();
+  const byRepo = /* @__PURE__ */ new Map();
+  const of = (r) => {
+    const x = byRepo.get(r) ?? { remove: [], add: [] };
+    byRepo.set(r, x);
+    return x;
+  };
+  const undoneBatches = /* @__PURE__ */ new Map();
+  const isUndone = async (batch) => {
+    if (!batch || batch === b.id)
+      return false;
+    if (!undoneBatches.has(batch))
+      undoneBatches.set(batch, !!(await readBatch(root, batch).catch(() => void 0))?.undone);
+    return undoneBatches.get(batch);
+  };
+  const batchOfLine = (line) => {
+    try {
+      return JSON.parse(line).batch;
+    } catch {
+      return void 0;
+    }
+  };
+  const stands = await batchStands(root, b);
+  if (!stands)
+    throw new DecideError("conflict", `Nothing of ${id} stands now: each of its lines and answers was changed since, so there is nothing to undo.`);
+  for (const i of b.applied)
+    if (i.kind === "link")
+      of(i.repo).remove.push(i.line);
+  for (const i of b.reverted)
+    if (i.kind === "link") {
+      if (await isUndone(batchOfLine(i.line))) {
+        skipped.push(`a line of an undone batch in ${correctionsRel(root, i.repo)}: not put back`);
+        continue;
+      }
+      of(i.repo).add.push(i.line);
+    }
+  for (const [repo, x] of byRepo) {
+    const r = await rewriteCorrections(root, repo, x);
+    removed += r.removed;
+    restored += r.added;
+    if (r.removed < x.remove.length)
+      skipped.push(`${x.remove.length - r.removed} of its lines in ${correctionsRel(root, repo)} were gone already`);
+    files.add(correctionsRel(root, repo));
+    repos.add(repo);
+  }
+  for (const i of [...b.applied].reverse()) {
+    if (i.kind !== "question")
+      continue;
+    const q = await readQuestion(root, i.id).catch(() => void 0);
+    if (!q || q.answer?.batch !== b.id) {
+      skipped.push(`${i.id} was answered again since: left as it is`);
+      continue;
+    }
+    const { answer: _a, ...rest } = q;
+    const before = i.before && !await isUndone(i.before.batch) ? i.before : void 0;
+    if (i.before && !before)
+      skipped.push(`${i.id}: its earlier answer was an undone batch's, so it is open`);
+    await writeQuestion(root, Question.parse(before ? { ...rest, state: "answered", answer: before } : { ...rest, state: "open" }));
+    removed++;
+    repos.add(q.repo);
+  }
+  for (const i of b.reverted) {
+    if (i.kind !== "question" || !i.before)
+      continue;
+    const q = await readQuestion(root, i.id).catch(() => void 0);
+    if (!q || q.state !== "open") {
+      skipped.push(`${i.id} was answered since: the AI's answer isn't put back`);
+      continue;
+    }
+    if (await isUndone(i.before.batch)) {
+      skipped.push(`${i.id}: the AI's answer was an undone batch's, so it stays open`);
+      continue;
+    }
+    await writeQuestion(root, Question.parse({ ...q, state: "answered", answer: i.before }));
+    restored++;
+    repos.add(q.repo);
+  }
+  if (b.applied.some((i) => i.kind === "question") || b.reverted.some((i) => i.kind === "question"))
+    files.add(`${questionsRelOf(root)}/`);
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const file = await writeBatch(root, { ...b, undone: { by: o.by, at } });
+  files.add(file);
+  return {
+    batch: b.id,
+    removed,
+    restored,
+    skipped,
+    files: [...files],
+    verify: [...repos].sort().map((r) => `atticus verify ${r} --write`),
+    commit: `git add ${[...files].join(" ")}
+git commit -m "${safeMessage(`Undo ${b.id}`)}"`
+  };
+}
+async function aiAuditCandidates(root, repo) {
+  const out = [];
+  for (const c of standingAi(await correctionsOf(root, repo)))
+    out.push({
+      id: `ai:link:${c.fact}`,
+      kind: "ai",
+      of: "link",
+      claim: `AI paired ${c.target.value} with ${[c.link.method, c.link.path].filter(Boolean).join(" ")} on ${c.link.repo}`,
+      cites: [`${repo} ${c.target.file}:${c.target.line}`],
+      fact: c.fact,
+      to: c.link.repo,
+      decided: c.link.entry ?? c.link.path,
+      run: c.ai.run
+    });
+  for (const q of (await listQuestions(root, { state: "answered" })).questions) {
+    if (q.repo !== repo || !q.answer || !isAiBy(q.answer.by))
+      continue;
+    const label = q.options[(q.answer.option ?? 0) - 1]?.label ?? "";
+    const cites = (q.answer.proposal?.cites ?? []).map((c) => `${c.repo ?? q.repo} ${c.file}:${c.line}`);
+    out.push({
+      id: `ai:question:${q.id}`,
+      kind: "ai",
+      of: "question",
+      claim: `AI answered "${q.question.trim()}" with ${label}`,
+      cites: cites.length ? cites : q.evidence.map((e) => `${q.repo} ${e}`),
+      decided: label,
+      run: q.answer.by.run
+    });
+  }
+  return out;
+}
+
+export {
+  DecideError,
+  inAcpSession,
+  decideState,
+  decideIn,
+  decideLinks,
+  proposalsSnapshot,
+  decideAnswers,
+  decisionsView,
+  correctDecision,
+  undoBatch,
+  aiAuditCandidates
+};