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

package/dist/{chunk-UDXWIPCB.js → chunk-RLDGWLQ7.js}

@@ -62,13 +62,15 @@ import {
   specEndpointIds,
   specFormatOf,
   vendorImpact
-} from "./chunk-CPK7QSBG.js";
-import "./chunk-YO2PKTXT.js";
-import "./chunk-TWQRPM76.js";
-import "./chunk-QHJJMZLX.js";
-import "./chunk-7AB6OWTV.js";
-import "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   CHANGE_INPUTS_SCHEMA_VERSION,

package/dist/chunk-RUGXBPWI.js

@@ -0,0 +1,384 @@
+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 {
+  generateTests,
+  matrixCsv,
+  matrixMarkdown,
+  traceMatrix,
+  writeTraceFindings
+} from "./chunk-BTGPE6CR.js";
+import {
+  DriftError,
+  SNIPPET_KINDS,
+  archiveGate,
+  driftExitCode,
+  driftJUnit,
+  driftJson,
+  driftMarkdown,
+  pipelineSnippet,
+  repoDrift
+} from "./chunk-ZQ7SKESZ.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  GlossaryError,
+  aliasDecision,
+  completeGlossaryDefinitions,
+  defineDecision,
+  linkDecision,
+  loadGlossary,
+  resolveTermId,
+  scanGlossary,
+  writeDecisions
+} from "./chunk-J2JAKCIW.js";
+import {
+  createGit
+} from "./chunk-PKBHS4AA.js";
+import {
+  runtimeForCli
+} from "./chunk-P32RUW3B.js";
+
+// packages/cli/dist/quality-commands.js
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var KNOWN = /* @__PURE__ */ new Set([
+  "TestgenError",
+  "PlannerError",
+  "ChangeError",
+  "ChangeFileError",
+  "GlossaryError",
+  "RuntimeConfigError"
+]);
+function fail(io, e) {
+  if (e instanceof Error && KNOWN.has(e.name)) {
+    io.err(e.message);
+    return e.code === "invalid" ? 2 : 1;
+  }
+  throw e;
+}
+var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+var lines = (io, text) => {
+  for (const l of text.trimEnd().split("\n"))
+    io.out(l);
+};
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+async function runtimeOf(root, mode, deps) {
+  if (deps.runtime)
+    return deps.runtime;
+  if (!mode && !process.env.ATTICUS_RUNTIME)
+    return void 0;
+  return (await runtimeForCli(root, mode ? { mode } : {})).runtime;
+}
+async function testsGenerate(root, changeId, storyId, o, io, deps = {}) {
+  if (!changeId || !storyId) {
+    io.err("Usage: atticus tests generate <change> <story> [--framework <id>] [--force] [--check] [--mode <mode>] [--json]");
+    return 2;
+  }
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await generateTests(root, changeId, storyId, {
+      ...o.framework ? { framework: o.framework } : {},
+      ...o.force ? { force: true } : {},
+      ...o.check ? { check: true } : {},
+      ...o.resume ? { resume: o.resume } : {},
+      ...runtime ? { runtime } : {},
+      now: deps.now?.() ?? /* @__PURE__ */ new Date()
+    });
+    const kept = r.files.filter((f) => f.action === "kept-edited" || f.action === "kept-not-generated");
+    if (o.json) {
+      io.out(JSON.stringify({
+        change: r.change,
+        story: r.story,
+        strategy: r.model.strategy,
+        kinds: r.model.kinds,
+        names: r.names.by,
+        ...r.names.waiting ? { waiting: r.names.waiting } : {},
+        files: r.files,
+        manifest: r.manifest,
+        notes: r.notes,
+        gaps: r.gaps
+      }, null, 2));
+      return kept.length ? 1 : 0;
+    }
+    const count = (a) => r.files.filter((f) => f.action === a).length;
+    const cases = r.model.repos.reduce((n, x) => n + x.cases.length, 0);
+    io.out(`${o.check ? "Would write" : "Generated"} ${plural(cases, "test case")} for ${r.story} in ${plural(r.files.length, "file")}: ${count("created")} new, ${count("updated")} updated, ${count("unchanged")} unchanged${kept.length ? `, ${kept.length} kept` : ""}.`);
+    for (const l of table(["ACTION", "REPO", "FRAMEWORK", "FILE"], r.files.map((f) => [f.action, f.repo || "-", f.generator, f.path])))
+      io.out(l);
+    for (const k of r.model.kinds.filter((x) => !x.generated))
+      io.out(`No ${k.type} tests: ${k.why}`);
+    for (const n of r.notes)
+      io.out(n);
+    for (const g of r.gaps)
+      io.out(`Gap: ${g}`);
+    if (r.names.waiting)
+      io.out(`The test writer is with your assistant (run ${r.names.waiting}); the files use plain names until you run: atticus tests generate ${changeId} ${storyId} --resume ${r.names.waiting}`);
+    if (!o.check)
+      io.out(`Manifest: ${r.manifest}`);
+    return kept.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function traceCommand(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus trace <change> [--json | --csv] [--no-write]");
+    return 2;
+  }
+  try {
+    const m = await traceMatrix(root, changeId, { git: deps.git ?? createGit() });
+    for (const p of m.problems)
+      io.err(p);
+    const w = o.write === false ? void 0 : await writeTraceFindings(root, m, iso(deps.now?.() ?? /* @__PURE__ */ new Date()));
+    if (o.json)
+      io.out(JSON.stringify({ ...m, ...w ? { round: w.round ?? null } : {} }, null, 2));
+    else if (o.csv)
+      lines(io, matrixCsv(m));
+    else {
+      lines(io, matrixMarkdown(m));
+      if (w)
+        io.out(w.unchanged ? `Findings on the trace gate are unchanged (round ${w.round ?? "none"}).` : `Wrote ${plural(w.findings.length, "finding")} to review/trace/${w.round}/.`);
+    }
+    return m.gaps.some((g) => g.kind !== "test-without-requirement") ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function ciDrift(repoDir, o, io, deps = {}) {
+  if (!o.catalog) {
+    io.err("Usage: atticus ci drift [repo-dir] --catalog <metarepo or catalog folder> [--repo <id>] [--json [file]] [--junit <file>] [--summary <file>] [--warn-only]");
+    return 2;
+  }
+  try {
+    const r = await repoDrift({
+      repoDir,
+      catalog: o.catalog,
+      ...o.repo ? { repo: o.repo } : {},
+      ...o.warnOnly ? { warnOnly: true } : {},
+      ...deps.commit ? { commit: deps.commit } : {},
+      ...deps.git ? { git: deps.git } : {}
+    });
+    const put = async (file, text) => {
+      await mkdir(dirname(file), { recursive: true });
+      await writeFile(file, text, "utf8");
+    };
+    if (typeof o.json === "string")
+      await put(o.json, driftJson(r));
+    if (o.junit)
+      await put(o.junit, driftJUnit(r));
+    if (o.summary) {
+      await mkdir(dirname(o.summary), { recursive: true });
+      await appendFile(o.summary, driftMarkdown(r), "utf8");
+    }
+    if (o.json === true)
+      io.out(driftJson(r).trimEnd());
+    else
+      lines(io, driftMarkdown(r));
+    return driftExitCode(r);
+  } catch (e) {
+    if (e instanceof DriftError) {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+}
+async function ciSnippet(kind, io, o = {}) {
+  const s = kind ? pipelineSnippet(kind) : void 0;
+  if (!s) {
+    io.err(`Usage: atticus ci snippet <${SNIPPET_KINDS.join("|")}> [--write <repo-dir>]`);
+    return 2;
+  }
+  if (o.write) {
+    const file = join(o.write, ...s.path.split("/"));
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, s.content, "utf8");
+    io.out(`Wrote ${s.path}. Set the variables its first lines name, then commit it.`);
+    return 0;
+  }
+  lines(io, s.content);
+  return 0;
+}
+async function ciArchiveGate(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus ci archive-gate <change> [--drift <report.json>...] [--json]");
+    return 2;
+  }
+  let r;
+  try {
+    r = await archiveGate(root, changeId, {
+      ...o.drift?.length ? { driftReports: o.drift } : {},
+      ...deps.commit ? { commit: deps.commit } : {}
+    });
+  } catch (e) {
+    if (e instanceof Error && e.name === "ChangeFileError") {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+  if (o.json)
+    io.out(JSON.stringify(r, null, 2));
+  else {
+    io.out(r.pass ? `${changeId} may be archived: no blockers, its release PRs merged and built, and the catalog says what shipped.` : `${changeId} can't be archived yet (${plural(r.blockers.length, "blocker")}):`);
+    for (const b of r.blockers)
+      io.out(`- ${b.message}`);
+    for (const n of r.notes)
+      io.out(n);
+  }
+  return r.pass ? 0 : 1;
+}
+var short = (s, n = 70) => s.length <= n ? s : `${s.slice(0, n - 3)}...`;
+var sourceOf = (flags, confidence) => confidence === "asserted" ? "person" : flags?.includes("ai-proposed") ? "ai" : flags?.includes("undefined") ? "code" : "wiki";
+async function glossaryList(root, o, io) {
+  const g = await loadGlossary(root);
+  for (const p of g.problems)
+    io.err(p);
+  if (o.json) {
+    io.out(JSON.stringify({
+      terms: g.terms,
+      conflicts: g.build.conflicts,
+      hints: g.build.hints,
+      synonyms: Object.fromEntries(g.build.entries.filter((e) => e.aliases.length).map((e) => [e.id, e.aliases]))
+    }, null, 2));
+    return 0;
+  }
+  if (!g.terms.length) {
+    io.out("The glossary is empty: no wiki page defines a term and the catalog has no domain words yet.");
+    return 0;
+  }
+  for (const l of table(["TERM", "ID", "FROM", "FLAGS", "DEFINITION"], g.terms.map((t) => [
+    t.term,
+    t.id,
+    sourceOf(t.flags, t.confidence),
+    (t.flags ?? []).join(","),
+    short(t.definition)
+  ])))
+    io.out(l);
+  io.out(`${plural(g.terms.length, "term")}, ${plural(g.build.conflicts.filter((c) => !c.resolved).length, "conflict")}.`);
+  return 0;
+}
+async function glossaryScan(root, o, io, deps = {}) {
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await scanGlossary(root, {
+      ...runtime ? { runtime } : {},
+      ...deps.now ? { now: deps.now() } : {}
+    });
+    if (o.json) {
+      for (const p of r.problems)
+        io.err(p);
+      io.out(JSON.stringify({
+        terms: r.terms.length,
+        written: r.written,
+        removed: r.removed,
+        conflicts: r.build.conflicts,
+        hints: r.build.hints,
+        ...r.propose ? { proposals: r.propose.proposals.length, discarded: r.propose.discarded } : {}
+      }, null, 2));
+      return 0;
+    }
+    printGlossaryScan(r, io);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function printGlossaryScan(r, io) {
+  for (const p of r.problems)
+    io.err(p);
+  const open = r.build.conflicts.filter((c) => !c.resolved);
+  io.out(`The glossary has ${plural(r.terms.length, "term")}; ${plural(r.written.length, "file")} written and ${plural(r.removed.length, "file")} removed in catalog/generated.`);
+  if (r.propose)
+    io.out(r.propose.waiting ? `The glossary definer is with your assistant (run ${r.propose.waiting}). When it is done, run: atticus handoff done ${r.propose.waiting}` : `The glossary definer proposed ${plural(r.propose.proposals.length, "definition")} (kept inferred until a person defines the term).`);
+  for (const d of r.propose?.discarded ?? [])
+    if (d.term && !r.propose?.waiting)
+      io.err(`Discarded ${d.term}: ${d.reason}`);
+  for (const c of open)
+    io.out(`Conflict: ${c.message}`);
+  for (const h of r.build.hints)
+    io.out(`Naming: ${h.message}`);
+}
+async function completeGlossaryScan(root, run, io, deps = {}) {
+  try {
+    const r = await completeGlossaryDefinitions(root, run, deps.now ? { now: deps.now } : {});
+    printGlossaryScan(r, io);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function decide(root, io, make, said) {
+  try {
+    const g = await loadGlossary(root);
+    const ds = make(g);
+    const files = await writeDecisions(join(g.catalogDir, "curated"), ds);
+    await scanGlossary(root);
+    io.out(`Wrote ${files.map((f) => `catalog/curated/${f}`).join(" and ")}: ${said}. Commit it so every scan keeps it.`);
+    return 0;
+  } catch (e) {
+    if (e instanceof GlossaryError) {
+      io.err(e.message);
+      return e.code === "invalid" ? 2 : 1;
+    }
+    throw e;
+  }
+}
+async function glossaryDefine(root, term, definition, o, io) {
+  if (!term || !definition || !o.by) {
+    io.err('Usage: atticus glossary define <term> "<definition>" [--by <handle>] [--owner <team>]');
+    return 2;
+  }
+  return decide(root, io, (g) => {
+    const existing = g.terms.find((t) => t.id === resolveTermId(term));
+    return [
+      defineDecision(term, definition, {
+        by: o.by,
+        ...o.owner ? { owner: o.owner } : {},
+        ...existing ? { existing } : {}
+      })
+    ];
+  }, `${resolveTermId(term)} is defined and asserted`);
+}
+async function glossaryLink(root, term, recordId, o, io) {
+  if (!term || !recordId || !o.by) {
+    io.err("Usage: atticus glossary link <term> <record-id | schema#field> [--by <handle>]");
+    return 2;
+  }
+  return decide(root, io, (g) => {
+    const id = resolveTermId(term);
+    const t = g.terms.find((x) => x.id === id);
+    if (!t)
+      throw new GlossaryError("not-found", `There is no term ${id}. Define it first: atticus glossary define`);
+    return [linkDecision(t, recordId, g.base, { by: o.by })];
+  }, `${recordId} is linked to ${resolveTermId(term)}`);
+}
+async function glossaryAlias(root, term, names, o, io) {
+  if (!term || !names.length || !o.by) {
+    io.err('Usage: atticus glossary alias <term> "<other name>"... [--by <handle>]');
+    return 2;
+  }
+  return decide(root, io, (g) => {
+    const id = resolveTermId(term);
+    const before = g.build.entries.find((e) => e.id === id)?.aliases ?? [];
+    return [aliasDecision(id, [...before, ...names], { by: o.by })];
+  }, `${names.join(", ")} ${names.length === 1 ? "is another name" : "are other names"} for ${resolveTermId(term)}`);
+}
+
+export {
+  testsGenerate,
+  traceCommand,
+  ciDrift,
+  ciSnippet,
+  ciArchiveGate,
+  glossaryList,
+  glossaryScan,
+  completeGlossaryScan,
+  glossaryDefine,
+  glossaryLink,
+  glossaryAlias
+};

package/dist/{chunk-FYBF5MB2.js → chunk-RXPJMEOW.js}

@@ -7,10 +7,10 @@ import {
   cliMarkdown,
   gradeDialect,
   kindsMarkdown
-} from "./chunk-P2VBXX7N.js";
+} from "./chunk-O7FDLW7L.js";
 import {
   generateTests
-} from "./chunk-EZIN5E5B.js";
+} from "./chunk-BTGPE6CR.js";
 import {
   DEFAULT_DONE,
   DESIGN_FORMAT,
@@ -33,19 +33,19 @@ import {
   storySteps,
   unfence,
   writesField
-} from "./chunk-BEPCKDCP.js";
+} from "./chunk-R7NYHMUU.js";
 import {
   DesignScreen
-} from "./chunk-HWD4JPU7.js";
+} from "./chunk-IVBOQAGB.js";
 import {
   BUILT_IN_CHECKS,
   runCritic
-} from "./chunk-K332XW7K.js";
+} from "./chunk-S4PMJU6H.js";
 import {
   buildGlossary,
   proposeDefinitions,
   undefinedCodeTerms
-} from "./chunk-4SLBCEPD.js";
+} from "./chunk-J2JAKCIW.js";
 import {
   askKnowledge,
   checkQuote,
@@ -60,16 +60,16 @@ import {
   termsOf,
   writeKnowledge,
   writeSnapshots
-} from "./chunk-64AADMTW.js";
+} from "./chunk-745DAZ4L.js";
 import {
   writeChangeRepos
-} from "./chunk-XOL3GFW2.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   MockRuntime,
   ReplayRuntime,
   RuntimeError,
   buildContextPack
-} from "./chunk-QHJJMZLX.js";
+} from "./chunk-P32RUW3B.js";
 import {
   AgentDefinition,
   KNOWLEDGE_KINDS,
@@ -81,10 +81,12 @@ import {
   parseRecord,
   projectFacts,
   recordPath,
-  require_dist,
   serializeRecord,
   stateDirOf
-} from "./chunk-PAINMSID.js";
+} from "./chunk-Q2TECDIT.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

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

@@ -16,24 +16,23 @@ import {
   outsideSystemsOf,
   phaseGates,
   statePhase
-} from "./chunk-HSZMPH5T.js";
+} from "./chunk-IDKCWSM5.js";
 import {
   daysBetween,
   knowledgeGaps,
   newestEvidence
-} from "./chunk-64AADMTW.js";
+} from "./chunk-745DAZ4L.js";
 import {
   BREAKING_SPEC,
   INSTRUCTION_RULES,
   PERSONAL_DATA_SPEC,
   buildContextPack,
-  estimateTokens,
   personalItem,
   quarantineItems,
   screenText,
   settle,
   toRunSummary
-} from "./chunk-QHJJMZLX.js";
+} from "./chunk-P32RUW3B.js";
 import {
   ASKED_GAP_STEP,
   AgentDefinition,
@@ -59,6 +58,7 @@ import {
   callsOfQuestion,
   changesDirOf,
   changesRelOf,
+  estimateTokens,
   external_exports,
   fileJudgments,
   findingPath,
@@ -77,15 +77,17 @@ import {
   quotedIn,
   readQuestion,
   repoReadOf,
-  require_dist,
   runsDirOf,
   stateDirOf,
   toCanonicalYaml,
   writeQuestion
-} from "./chunk-PAINMSID.js";
+} from "./chunk-Q2TECDIT.js";
 import {
   writeFileAtomic
-} from "./chunk-ODMBPDDV.js";
+} from "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -3564,7 +3566,8 @@ async function roundsOf(root, change, gate) {
 async function countedRounds(root, change, gate) {
   const out = [];
   for (const n of await roundsOf(root, change, gate)) {
-    const m = await readRoundMeta(root, change, gate, n);
+    const m0 = await readRoundMeta(root, change, gate, n);
+    const m = m0?.state === "in-progress" ? void 0 : m0;
     if (!m) {
       const r = await readRound(root, change, gate, n);
       if (!r.findings.length && !r.bad.length)
@@ -5360,6 +5363,15 @@ async function runCritic(root, changeId, opts = {}) {
     problems.push(`Rule ${h.rule.id} produced a finding without evidence; it was discarded: ${h.hit.summary}`);
   const merged1 = mergeHits(l1.filter((h) => h.hit.evidence.length > 0), ctx.systemOf);
   const failed = new Set(merged1.filter((h) => h.hit.kind === "issue" && h.rule.severity === "blocking" && h.hit.artifact !== "catalog").map((h) => h.hit.artifact));
+  const metaDir = join10(changeFolder(root, change.id), "review", gate.id, String(round), "meta");
+  await writeFileAtomic(join10(metaDir, "round.yaml"), toCanonicalYaml({
+    schemaVersion: 1,
+    change: change.id,
+    gate: gate.id,
+    round,
+    createdAt: now,
+    state: "in-progress"
+  }, ROUND_LEADING));
   const lenses = opts.lenses ? questionsOf(opts.lenses) : [...CriticQuestion.options];
   const quarantined = [];
   const draft = opts.review ? await draftDocs(changeFolder(root, change.id), opts.review.files) : [];
@@ -5444,7 +5456,6 @@ async function runCritic(root, changeId, opts = {}) {
   ];
   await keepLensRecords(root, change.id, gate.id, round, ai.runs);
   const model = criticModel(lifecycle.orgPack.runtime, opts.authorModel);
-  const metaDir = join10(changeFolder(root, change.id), "review", gate.id, String(round), "meta");
   for (const r of ai.runs)
     if (r.summary)
       await writeFileAtomic(join10(metaDir, "runs", `${r.agent}.yaml`), toCanonicalYaml(r.summary, ["schemaVersion", "runId"]));

package/dist/{chunk-THN26IEF.js → chunk-S7FCV7S5.js}

@@ -3,6 +3,9 @@ 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 {
+  withSharedFileLock
+} from "./chunk-TUULXQRW.js";
 
 // packages/cli/dist/file-lock.js
 import { appendFile, readFile } from "node:fs/promises";
@@ -21,7 +24,7 @@ function withFileLock(path, work) {
   return next;
 }
 function appendLines(file, lines) {
-  return withFileLock(file, async () => {
+  return withSharedFileLock(file, async () => {
     const now = await readFile(file, "utf8").catch(() => "");
     const eol = /\r\n/.test(now) ? "\r\n" : "\n";
     const lead = now && !now.endsWith("\n") ? eol : "";

package/dist/{chunk-OV57AHCG.js → chunk-SDKLKB6I.js}

@@ -6,25 +6,25 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   prepareKnowledgeBench,
   runKnowledgeBench
-} from "./chunk-FYBF5MB2.js";
-import "./chunk-36RY7ZXM.js";
-import "./chunk-2V2ZPQQU.js";
-import "./chunk-P2VBXX7N.js";
-import "./chunk-EZIN5E5B.js";
-import "./chunk-3LZ6P5EP.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 {
   codeFactRecords
-} from "./chunk-BEPCKDCP.js";
-import "./chunk-HWD4JPU7.js";
-import "./chunk-5WERBKLE.js";
+} from "./chunk-R7NYHMUU.js";
+import "./chunk-IVBOQAGB.js";
+import "./chunk-ISUAAMGS.js";
 import {
   table
 } from "./chunk-VOGCSYOI.js";
-import "./chunk-K332XW7K.js";
-import "./chunk-HSZMPH5T.js";
-import "./chunk-D2WSW4GU.js";
-import "./chunk-4KNOJC6J.js";
-import "./chunk-4SLBCEPD.js";
+import "./chunk-S4PMJU6H.js";
+import "./chunk-IDKCWSM5.js";
+import "./chunk-UUU4CLJG.js";
+import "./chunk-7IGKHZ4Z.js";
+import "./chunk-J2JAKCIW.js";
 import {
   askKnowledge,
   conflictLine,
@@ -50,17 +50,18 @@ import {
   tagList,
   writeKnowledge,
   writeReview
-} from "./chunk-64AADMTW.js";
-import "./chunk-JYMIB5XY.js";
-import "./chunk-CPK7QSBG.js";
-import "./chunk-YO2PKTXT.js";
-import "./chunk-TWQRPM76.js";
-import "./chunk-XOL3GFW2.js";
+} from "./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 {
   RuntimeConfigError,
   runtimeForCli
-} from "./chunk-QHJJMZLX.js";
-import "./chunk-7AB6OWTV.js";
+} from "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
 import {
   KNOWLEDGE_KINDS,
   fileJudgments,
@@ -68,8 +69,9 @@ import {
   knowledgeRelOf,
   loadOrgPack,
   orgPackDirOf
-} from "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/knowledge-scan-commands.js