@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.3

package/dist/chunk-GRMR5TRQ.js

@@ -0,0 +1,119 @@
+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 {
+  loadCatalog
+} from "./chunk-2UIQBDJO.js";
+import {
+  TARGET_DIR,
+  mergeDelta,
+  readDeltas
+} from "./chunk-VPTTCYOC.js";
+import {
+  changeStore
+} from "./chunk-56YQ6ROQ.js";
+import {
+  changeView,
+  toDrawio,
+  toMermaid
+} from "./chunk-PAMPPUR6.js";
+import {
+  changesDirOf,
+  changesRelOf,
+  readRepoSpec,
+  specRepos
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/change-map.js
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+async function targetFlowsOf(root, change) {
+  const dir = join(changesDirOf(root), change);
+  if (!await stat(join(dir, "change.yaml")).catch(() => void 0))
+    return void 0;
+  const title = await changeStore(root).read(change).then((c) => c.title).catch(() => change);
+  const { deltas, problems } = await readDeltas(dir);
+  const repos = new Set(await specRepos(root));
+  const specs = /* @__PURE__ */ new Map();
+  const merged = [];
+  for (const d of deltas) {
+    if (repos.has(d.repo) && !specs.has(d.repo))
+      specs.set(d.repo, await readRepoSpec(root, d.repo, { cacheRoot: root }));
+    const m = mergeDelta(d, specs.get(d.repo)?.flows.find((f) => f.id === d.flow));
+    problems.push(...m.problems);
+    merged.push(m);
+  }
+  const { records } = await loadCatalog(root, { out: () => void 0, err: () => void 0 });
+  const known = /* @__PURE__ */ new Set();
+  for (const repo of repos) {
+    const spec = specs.get(repo) ?? await readRepoSpec(root, repo, { cacheRoot: root });
+    for (const f of spec.flows)
+      known.add(f.component);
+  }
+  return {
+    title,
+    source: `${changesRelOf(root)}/${change}/${TARGET_DIR}`,
+    merged,
+    problems,
+    records,
+    known
+  };
+}
+async function changeMapOf(root, change) {
+  const t = await targetFlowsOf(root, change);
+  if (!t)
+    return void 0;
+  return {
+    view: changeView(t.records, { id: change, title: t.title, source: t.source }, t.merged, t.known),
+    title: t.title,
+    source: t.source,
+    flows: t.merged.length,
+    problems: t.problems
+  };
+}
+function changeMapBody(change, m) {
+  return {
+    change,
+    title: m.title,
+    source: m.source,
+    groups: m.view.groups,
+    nodes: m.view.nodes,
+    edges: m.view.edges,
+    mermaid: toMermaid(m.view),
+    flows: m.flows,
+    problems: m.problems
+  };
+}
+async function changeMapCommand(root, change, o, io) {
+  const format = o.format ?? "mermaid";
+  if (format !== "mermaid" && format !== "drawio") {
+    io.err(`Unknown format "${format}": use mermaid or drawio.`);
+    return 2;
+  }
+  const m = await changeMapOf(root, change);
+  if (!m) {
+    io.err(`There is no change ${change}.`);
+    return 2;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(changeMapBody(change, m), null, 2));
+    return 0;
+  }
+  for (const p of m.problems)
+    io.err(p);
+  if (!m.flows) {
+    io.err(`${change} has no target flows yet, so there is nothing to draw: the architecture stage writes them (atticus change architecture ${change}).`);
+    return 1;
+  }
+  io.out((format === "drawio" ? toDrawio(m.view) : toMermaid(m.view)).replace(/\n$/, ""));
+  return 0;
+}
+
+export {
+  targetFlowsOf,
+  changeMapOf,
+  changeMapBody,
+  changeMapCommand
+};

package/dist/chunk-HC6XKREB.js

@@ -0,0 +1,334 @@
+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 "./chunk-5A5L3T2U.js";
+import {
+  loadCatalog
+} from "./chunk-2UIQBDJO.js";
+import {
+  repoFor
+} from "./chunk-CMV7TGU6.js";
+import {
+  recordFact,
+  verifyScan
+} from "./chunk-DPC5Y5DL.js";
+import "./chunk-ZVM6AKKM.js";
+import {
+  stepJudges
+} from "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import {
+  checkScanSettings
+} from "./chunk-OLWFG75W.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-KJPMEAI4.js";
+import {
+  fsRepo
+} from "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  SCAN_VERIFY_SCHEMA_VERSION,
+  ScanSettings,
+  ScanVerifyProposal,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  proposalsDirOf,
+  proposalsRelOf,
+  questionsRelOf,
+  raiseQuestions,
+  require_dist,
+  reusedLine
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/scan-verify-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var KIND_WORDS = {
+  "entry-point": "entry point",
+  call: "call",
+  table: "table",
+  deployment: "deployment",
+  other: "fact"
+};
+var fixWords = (f) => "settings" in f ? "a scan settings entry" : "question" in f ? "a question for a person" : "a reader must change";
+var sentence = (s) => {
+  const t = s.trim();
+  return `${t.charAt(0).toUpperCase()}${t.slice(1)}${/[.!?]$/.test(t) ? "" : "."}`;
+};
+var proposalFile = (root, repo) => join(proposalsDirOf(root), "scan", `${repo}.yaml`);
+var findingsFile = (root, repo) => join(proposalsDirOf(root), "scan", `${repo}.findings.md`);
+var EMPTY = { exclude: [], prefixes: [], clients: [] };
+function newEntries(have, add) {
+  const ex = (e) => e.path;
+  const px = (p) => `${p.paths.join(",")} ${p.prefix}`;
+  const cl = (c) => `${c.paths.join(",")} ${c.base} ${c.names.join(",")}`;
+  const fresh = (had, more, key) => {
+    const seen = new Set(had.map(key));
+    return more.filter((x) => {
+      const k = key(x);
+      if (seen.has(k))
+        return false;
+      seen.add(k);
+      return true;
+    });
+  };
+  return {
+    exclude: fresh(have.exclude, add.exclude, ex),
+    prefixes: fresh(have.prefixes, add.prefixes, px),
+    clients: fresh(have.clients, add.clients, cl)
+  };
+}
+var merge = (a, b) => {
+  const n = newEntries(a, b);
+  return {
+    exclude: [...a.exclude, ...n.exclude],
+    prefixes: [...a.prefixes, ...n.prefixes],
+    clients: [...a.clients, ...n.clients]
+  };
+};
+var size = (s) => s.exclude.length + s.prefixes.length + s.clients.length;
+var describeSettings = (s) => [
+  s.exclude.length ? plural(s.exclude.length, "folder") + " left out" : "",
+  s.prefixes.length ? plural(s.prefixes.length, "prefix", "prefixes") : "",
+  s.clients.length ? plural(s.clients.length, "client base") : ""
+].filter(Boolean).join(", ");
+async function readProposal(root, repo) {
+  const text = await readFile(proposalFile(root, repo), "utf8").catch(() => void 0);
+  return text === void 0 ? void 0 : ScanVerifyProposal.parse((0, import_yaml.parse)(text));
+}
+async function writeProposal(root, p) {
+  await mkdir(join(proposalsDirOf(root), "scan"), { recursive: true });
+  await writeFile(proposalFile(root, p.repo), `# From atticus scan verify (ADR 0082): every item was checked against the code. Accept the settings with atticus scan verify ${p.repo} --accept.
+${(0, import_yaml.stringify)(ScanVerifyProposal.parse(p))}`, "utf8");
+}
+var ofRepo = (records, repo) => records.filter((r) => r.evidence.some((e) => e.repo === repo));
+async function pin(repo, r) {
+  const e = r.evidence.find((x) => x.path) ?? r.evidence[0];
+  if (!e?.path)
+    return { record: r.id, at: "?" };
+  if (!e.line)
+    return { record: r.id, at: e.path };
+  const text = await repo.readText(e.path).catch(() => void 0);
+  const line = text?.replace(/\r\n?/g, "\n").split("\n")[e.line - 1];
+  return {
+    record: r.id,
+    at: `${e.path}:${e.line}`,
+    ...line !== void 0 ? { line: createHash("sha256").update(line.trim()).digest("hex").slice(0, 12) } : {}
+  };
+}
+function findings(repo, r, now, records) {
+  const a = r.answer;
+  const items = [];
+  for (const m of a.missed)
+    if ("reader" in m.fix)
+      items.push(`- Missed the ${KIND_WORDS[m.kind]} ${m.method ? `${m.method} ` : ""}${m.name} at ${m.at}. ${sentence(m.why)} What must change: ${sentence(m.fix.reader)}`);
+  for (const w of a.wrong)
+    if ("reader" in w.fix) {
+      const rec = records.find((x) => x.id === w.record);
+      const f = rec ? recordFact(rec) : void 0;
+      items.push(`- Wrong: ${w.record}${f ? ` (the ${KIND_WORDS[f.kind]} ${f.method ? `${f.method} ` : ""}${f.name})` : ""}, shown by ${w.at}. ${sentence(w.why)} What must change: ${sentence(w.fix.reader)}`);
+    }
+  const text = [
+    `# What the scan of ${repo} reads wrong`,
+    "",
+    `Found by atticus scan verify on ${now.toISOString().slice(0, 10)}${r.runId ? ` (run ${r.runId})` : ""}. No scan setting can put these right: each needs a change to a built-in reader or a scanner plugin (ADR 0080). Atticus checked that each cited line says what is quoted.`,
+    "",
+    ...items.length ? items : ["Nothing this time."],
+    ""
+  ].join("\n");
+  return { text, count: items.length };
+}
+async function scanVerify(root, target, o, deps, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+    return 2;
+  }
+  const { records: all } = await loadCatalog(root, { out: () => {
+  }, err: (l) => io.err(l) });
+  const records = ofRepo(all, repo.id);
+  if (records.length === 0) {
+    io.err(`The catalog has nothing from ${repo.id} yet: run atticus scan first.`);
+    return 1;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const settings = op.scanSettings.find((s) => s.repo === repo.id);
+  const before = await listQuestions(root, { repo: repo.id }).then((l) => ({
+    ...l,
+    questions: l.questions.filter((q) => q.state !== "retired")
+  }));
+  const handle = fsRepo(repo.id, repo.dir, "0".repeat(40));
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const r = await verifyScan(handle, {
+    repoId: repo.id,
+    runtime: deps.runtime,
+    records,
+    ...settings ? { settings } : {},
+    orgPack: op,
+    maxAttempts: o.attempts ?? 3,
+    questions: before.questions,
+    now,
+    ...o.resume ? { resume: o.resume } : {}
+  });
+  if (r.status === "waiting") {
+    io.out(`Handed the check to your assistant (run ${r.runId}). When it is done: atticus handoff done ${r.runId}, then atticus scan verify ${repo.id} --resume ${r.runId}`);
+    return 0;
+  }
+  const handedBack = r.attempts.filter((x, n) => x.problems.length > 0 && n < r.attempts.length - 1);
+  if (r.status !== "checked" || !r.answer) {
+    if (o.json)
+      io.out(JSON.stringify({ status: r.status, attempts: r.attempts }, null, 2));
+    else {
+      for (const a2 of r.attempts) {
+        io.out(`Attempt ${a2.attempt}: ${plural(a2.problems.length, "problem")}:`);
+        for (const p of a2.problems)
+          io.out(`  - ${p}`);
+      }
+      io.out(`No answer could be read in ${plural(r.attempts.length, "attempt")}; nothing was written.`);
+    }
+    return 1;
+  }
+  const a = r.answer;
+  let fixes = EMPTY;
+  for (const item of [...a.missed, ...a.wrong])
+    if ("settings" in item.fix)
+      fixes = merge(fixes, item.fix.settings);
+  const earlier = await readProposal(root, repo.id).catch(() => void 0);
+  const proposed = newEntries(settings ?? EMPTY, merge(earlier?.settings ?? EMPTY, fixes));
+  const drafts = [...a.missed, ...a.wrong].flatMap((x) => "question" in x.fix ? [x.fix.question] : []);
+  const judges = stepJudges(root, deps.runtime, repo.id, now);
+  const { raised, known, reused } = await raiseQuestions(root, drafts, {
+    step: "scan-verify",
+    repo: repo.id,
+    command: `atticus scan verify ${repo.id}`,
+    rerun: `atticus scan verify ${repo.id}`,
+    ...r.runId ? { run: r.runId } : {},
+    at: now.toISOString()
+  }, judges);
+  const byId = new Map(records.map((x) => [x.id, x]));
+  const verified = await Promise.all(a.confirmed.map((c) => c.record).sort().map((id) => pin(handle, byId.get(id))));
+  const proposal = {
+    schemaVersion: SCAN_VERIFY_SCHEMA_VERSION,
+    repo: repo.id,
+    ...r.runId ? { run: r.runId } : {},
+    at: now.toISOString(),
+    settings: proposed,
+    missed: a.missed,
+    wrong: a.wrong.map((w) => ({ ...w, ...recordFact(byId.get(w.record)) })),
+    verified,
+    questions: [...new Set([...raised, ...known].map((q) => q.id))].sort(),
+    ...earlier?.accepted ? { accepted: earlier.accepted } : {}
+  };
+  await writeProposal(root, proposal);
+  const f = findings(repo.id, r, now, records);
+  await writeFile(findingsFile(root, repo.id), f.text, "utf8");
+  const rel = proposalsRelOf(root);
+  if (o.json) {
+    io.out(JSON.stringify({
+      status: r.status,
+      proposal,
+      refused: r.refused,
+      attempts: r.attempts,
+      questions: { raised: raised.map((q) => q.id), known: known.map((q) => q.id) },
+      files: {
+        proposal: `${rel}/scan/${repo.id}.yaml`,
+        findings: `${rel}/scan/${repo.id}.findings.md`
+      }
+    }, null, 2));
+    return 0;
+  }
+  io.out(`Checked ${repo.id} against its last scan: ${a.missed.length} missed, ${a.wrong.length} wrong, ${a.confirmed.length} confirmed.`);
+  for (const at of handedBack) {
+    io.out(`Attempt ${at.attempt}: ${plural(at.problems.length, "problem")}, handed back:`);
+    for (const p of at.problems)
+      io.out(`  - ${p}`);
+  }
+  if (r.refused.length) {
+    io.out("Left out, because the last attempt still failed its checks:");
+    for (const p of r.refused)
+      io.out(`  - ${p}`);
+  }
+  for (const m of a.missed)
+    io.out(`  missed: ${KIND_WORDS[m.kind]} ${m.method ? `${m.method} ` : ""}${m.name} (${m.at}); ${fixWords(m.fix)}`);
+  for (const w of a.wrong)
+    io.out(`  wrong: ${w.record} (${w.at}); ${fixWords(w.fix)}`);
+  io.out(`Wrote ${rel}/scan/${repo.id}.yaml: ${plural(size(proposed), "settings entry", "settings entries")} to accept, ${plural(verified.length, "record")} confirmed.`);
+  if (f.count)
+    io.out(`Wrote ${rel}/scan/${repo.id}.findings.md: ${plural(f.count, "thing")} a reader or a scanner plugin must read differently.`);
+  const waiting = known.filter((q) => q.state === "open");
+  if (raised.length) {
+    io.out(`${plural(raised.length, "question")} for a person, in ${questionsRelOf(root)}/:`);
+    for (const q of raised)
+      io.out(`  ${q.id} ${q.question}`);
+  }
+  for (const q of reused)
+    io.out(reusedLine(q));
+  if (waiting.length)
+    io.out(`${plural(waiting.length, "question")} still waiting for an answer: ${waiting.map((q) => q.id).join(", ")}`);
+  if (raised.length + waiting.length)
+    io.out(`Answer with atticus questions answer <id> --option <n>, or on the app's Questions page; then run atticus scan verify ${repo.id} again.`);
+  io.out(size(proposed) ? `Next: review ${rel}/scan/${repo.id}.yaml, then atticus scan verify ${repo.id} --accept, and atticus scan.` : `Next: nothing to accept; see ${rel}/scan/${repo.id}.findings.md for what a reader must change.`);
+  return 0;
+}
+async function scanVerifyAccept(root, target, o, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+    return 2;
+  }
+  const proposal = await readProposal(root, repo.id);
+  if (!proposal) {
+    io.err(`There is no proposal for ${repo.id} yet: run atticus scan verify ${repo.id} first.`);
+    return 1;
+  }
+  if (size(proposal.settings) === 0) {
+    io.out(`Nothing to accept for ${repo.id}: the proposal has no settings entries.`);
+    return 0;
+  }
+  const file = join(orgPackDirOf(root), "scan", `${repo.id}.yaml`);
+  const text = await readFile(file, "utf8").catch(() => void 0);
+  const have = text ? ScanSettings.parse((0, import_yaml.parse)(text)) : ScanSettings.parse({ schemaVersion: 1, repo: repo.id });
+  const added = newEntries(have, proposal.settings);
+  const next = ScanSettings.parse({ ...have, ...merge(have, added) });
+  const checked = await checkScanSettings(next, fsRepo(repo.id, repo.dir, "0".repeat(40)));
+  if (checked.problems.length) {
+    io.err(`The settings no longer check out against the code, so nothing was merged:`);
+    for (const p of checked.problems)
+      io.err(`  - ${p}`);
+    return 1;
+  }
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  await mkdir(join(orgPackDirOf(root), "scan"), { recursive: true });
+  await writeFile(file, `# Scan settings for ${repo.id} (ADR 0075); entries accepted from atticus scan verify on ${now.toISOString().slice(0, 10)} by ${o.by} (ADR 0082). Review it like any org-pack change.
+${(0, import_yaml.stringify)(next)}`, "utf8");
+  await writeProposal(root, {
+    ...proposal,
+    settings: EMPTY,
+    accepted: { at: now.toISOString(), by: o.by, entries: size(added) }
+  });
+  io.out(`Merged ${plural(size(added), "entry", "entries")} into org-pack/scan/${repo.id}.yaml${size(added) ? `: ${describeSettings(added)}` : ""}. Review it in a pull request, then run atticus scan.`);
+  return 0;
+}
+export {
+  scanVerify,
+  scanVerifyAccept
+};

package/dist/chunk-HFQCFSJR.js

@@ -0,0 +1,60 @@
+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 {
+  DEFAULT_IGNORES,
+  DEFAULT_PARSE_CACHE_LIMITS,
+  PLUGIN_EXTRACTOR_PREFIX,
+  PluginRunError,
+  RepoReadError,
+  cacheKeyHash,
+  configHash,
+  createParseCache,
+  deepFreeze,
+  defineExtractor,
+  fsRepo,
+  fsScanCache,
+  globToRegExp,
+  memoryRepo,
+  memoryScanCache,
+  pluginEntryHash,
+  readPinnedEntry,
+  runExtractor,
+  runTranslator,
+  sandboxedExtractor,
+  scanRepo,
+  stampEvidence,
+  tooLargeMessage,
+  withParseCache
+} from "./chunk-GQ4N4WKF.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  DEFAULT_IGNORES,
+  DEFAULT_PARSE_CACHE_LIMITS,
+  PLUGIN_EXTRACTOR_PREFIX,
+  PluginRunError,
+  RepoReadError,
+  cacheKeyHash,
+  configHash,
+  createParseCache,
+  deepFreeze,
+  defineExtractor,
+  fsRepo,
+  fsScanCache,
+  globToRegExp,
+  memoryRepo,
+  memoryScanCache,
+  pluginEntryHash,
+  readPinnedEntry,
+  runExtractor,
+  runTranslator,
+  sandboxedExtractor,
+  scanRepo,
+  stampEvidence,
+  tooLargeMessage,
+  withParseCache
+};

package/dist/chunk-HJDICQA4.js

@@ -0,0 +1,102 @@
+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 {
+  INPUTS_SOURCE_ID
+} from "./chunk-ABWHYWNI.js";
+import {
+  readCatalog
+} from "./chunk-OLWFG75W.js";
+import {
+  readKnowledge,
+  readSnapshot
+} from "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import {
+  scanInputs
+} from "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  catalogDirOf,
+  inputsDirOf,
+  knowledgeRelOf,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/documents.js
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+var titleOf = (r) => "title" in r && typeof r.title === "string" && r.title || "name" in r && typeof r.name === "string" && r.name || r.id;
+async function listDocuments(root) {
+  const dir = inputsDirOf(root);
+  const commands = [
+    `atticus sources sync --source ${INPUTS_SOURCE_ID}`,
+    `atticus knowledge scan --source ${INPUTS_SOURCE_ID}`
+  ];
+  const there = await stat(dir).then((s) => s.isDirectory(), () => false);
+  if (!there)
+    return { documents: [], snapshot: null, commands };
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const records = [];
+  for (const part of ["generated", "curated"])
+    records.push(...await readCatalog(join(catalogDirOf(root), part), { cacheRoot: root }).then((c) => c.records, () => []));
+  const intake = await scanInputs({
+    root,
+    orgPack: op,
+    inputsDir: dir,
+    records,
+    scannedAt: "1970-01-01T00:00:00Z"
+  });
+  const byId = new Map(intake.documents.filter((d) => d.id).map((d) => [d.id, d.path]));
+  const snap = await readSnapshot(root, INPUTS_SOURCE_ID).catch(() => void 0);
+  const read = new Set(snap?.manifest.pages.map((p) => `inputs/${p.page}`) ?? []);
+  const skipped = new Map(snap?.manifest.skipped.map((s) => [s.page, s.reason]) ?? []);
+  const fileOf = new Map(snap?.manifest.pages.map((p) => [p.file, `inputs/${p.page}`]) ?? []);
+  const copy = new RegExp(`^${knowledgeRelOf(root).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/snapshots/${INPUTS_SOURCE_ID}/[^/]+/(.+)$`);
+  const k = await readKnowledge(root, { cacheRoot: root }).catch(() => void 0);
+  const itemsOf = /* @__PURE__ */ new Map();
+  for (const item of k?.items ?? []) {
+    const files = new Set(item.evidence.map((e) => e.path ? copy.exec(e.path)?.[1] : void 0).filter((f) => !!f).map((f) => fileOf.get(f)).filter((p) => !!p));
+    const review = k.reviews[item.id];
+    for (const f of files)
+      itemsOf.set(f, [
+        ...itemsOf.get(f) ?? [],
+        {
+          id: item.id,
+          title: titleOf(item),
+          verified: review?.state === "verified" || review?.state === "corrected"
+        }
+      ]);
+  }
+  const documents = [];
+  for (const d of [...intake.documents].sort((a, b) => a.path < b.path ? -1 : 1)) {
+    const at = await stat(join(dir, ...d.path.replace(/^inputs\//, "").split("/"))).catch(() => void 0);
+    const reason = skipped.get(d.path);
+    documents.push({
+      path: d.path,
+      kind: d.classification,
+      ...d.title ? { title: d.title } : {},
+      systems: d.systems,
+      state: read.has(d.path) ? "read" : reason ? "skipped" : "not-synced",
+      ...reason ? { reason } : {},
+      ...d.duplicateOf ? { duplicateOf: d.duplicateOf } : {},
+      ...d.supersededBy ? { supersededBy: byId.get(d.supersededBy) ?? d.supersededBy } : {},
+      inbox: d.path.startsWith("inputs/inbox/"),
+      ...at ? { modifiedAt: at.mtime.toISOString() } : {},
+      items: itemsOf.get(d.path) ?? []
+    });
+  }
+  return { documents, snapshot: snap ? { date: snap.manifest.date } : null, commands };
+}
+export {
+  listDocuments
+};