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

package/dist/chunk-TM7LC37P.js

@@ -0,0 +1,4044 @@
+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 {
+  listRuns,
+  runTranscript
+} from "./chunk-IZNSAEBX.js";
+import {
+  historyEntry,
+  listHistory
+} from "./chunk-MH5OCRUM.js";
+import {
+  uiFactsRoutes
+} from "./chunk-NPCD54I7.js";
+import {
+  answerAudit,
+  auditLines,
+  defaultAuditSeed,
+  precisionOf,
+  prepareAudit,
+  writeAudit
+} from "./chunk-6GWHKMQR.js";
+import "./chunk-3GTZ2OON.js";
+import {
+  uiCiteRoutes
+} from "./chunk-YVLMBAYE.js";
+import {
+  HttpError,
+  badRequest,
+  conflict,
+  notFound,
+  startServer,
+  strParam
+} from "./chunk-HHUFVJF7.js";
+import "./chunk-IUD3ME4E.js";
+import {
+  isHandoffStep
+} from "./chunk-4Q3NN7VF.js";
+import {
+  estimateOf
+} from "./chunk-X4W4XXWP.js";
+import {
+  changeMapBody,
+  changeMapOf
+} from "./chunk-67J3VZBA.js";
+import {
+  changeArchive,
+  changeHandoff,
+  changeNew,
+  changeSync
+} from "./chunk-4PJADZRR.js";
+import {
+  conformanceCommand
+} from "./chunk-XRO65C7V.js";
+import {
+  outcomeList,
+  outcomeRecord,
+  releaseEvidenceCommand,
+  releaseForecastCommand,
+  releaseNotesCommand,
+  releasePlanCommand,
+  releaseSecurityCommand
+} from "./chunk-5MI2SEV5.js";
+import {
+  taskRun
+} from "./chunk-YPIEYQF4.js";
+import "./chunk-XB5RFZHH.js";
+import {
+  executorsCheck,
+  todoDone,
+  todoRun,
+  todoShow
+} from "./chunk-TZDSDDSV.js";
+import {
+  inputsSha256,
+  loadExecutors
+} from "./chunk-PIVKU64W.js";
+import {
+  isSandbox,
+  learnCheck,
+  learnStart,
+  lessonsFor,
+  readProgress,
+  sandboxCreate
+} from "./chunk-7UKVYFQ2.js";
+import {
+  defencesScan,
+  evalRun
+} from "./chunk-6GNS32SI.js";
+import {
+  listReports,
+  readQuality
+} from "./chunk-AWECWW5Y.js";
+import {
+  readServiceRequests
+} from "./chunk-5YIBJXGB.js";
+import {
+  initiativeStatus,
+  readView
+} from "./chunk-UYYN2IUZ.js";
+import {
+  reconcileCommand
+} from "./chunk-F7UQR4ZX.js";
+import {
+  sourcesAdd,
+  sourcesSync
+} from "./chunk-F2FOQLJ7.js";
+import {
+  INPUTS_SOURCE_ID
+} from "./chunk-IV7BCWWN.js";
+import "./chunk-P3TKKBAH.js";
+import {
+  intakeContext
+} from "./chunk-WARBF2KY.js";
+import {
+  baselineCommand,
+  setupSteps
+} from "./chunk-XTVDAHH2.js";
+import {
+  uiOnboardingRoutes
+} from "./chunk-2RX7PI2Y.js";
+import "./chunk-HE4ZQXZM.js";
+import {
+  uiTrustRoutes
+} from "./chunk-2KDSXJFJ.js";
+import "./chunk-B3O52AUQ.js";
+import "./chunk-XKS6THI5.js";
+import {
+  readMe,
+  writeMe
+} from "./chunk-UBWCUP3G.js";
+import {
+  digestCommand
+} from "./chunk-4QUQEBFT.js";
+import {
+  scanCommand
+} from "./chunk-7TGYNOXD.js";
+import "./chunk-LRS573EX.js";
+import {
+  catalogRecords,
+  openChanges,
+  systemGuide
+} from "./chunk-DPHCFZ7W.js";
+import {
+  doctorChecks
+} from "./chunk-FV5YFR6I.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-Y4BRGOJR.js";
+import "./chunk-R64GLVBO.js";
+import {
+  handoffDone,
+  workspaceOpen,
+  workspaceSync
+} from "./chunk-APSVL2AI.js";
+import "./chunk-23M2LUYM.js";
+import "./chunk-Y5PZHS4K.js";
+import {
+  readChangeTasks,
+  readStory
+} from "./chunk-IDGSU7JF.js";
+import {
+  ASSISTANT_FORMATS,
+  readProbes,
+  whatRunsWhere
+} from "./chunk-LK44ULGI.js";
+import {
+  critic,
+  criticStats,
+  findingAction
+} from "./chunk-73VPWF5R.js";
+import "./chunk-J5LHDJU4.js";
+import {
+  planStories,
+  snowDraft,
+  snowSubmit
+} from "./chunk-YXJ4XOHF.js";
+import "./chunk-ROTY5J2L.js";
+import {
+  archiveGate,
+  ciArchiveGate
+} from "./chunk-ZE3P35DA.js";
+import {
+  traceMatrix
+} from "./chunk-7YYEKTYF.js";
+import "./chunk-XEG3FE2R.js";
+import {
+  NEEDS_FILE,
+  PlannerError,
+  SYNC_FILE,
+  TARGET_DIR,
+  codeFactRecords,
+  commentOnFinding,
+  conflictTouches,
+  markNeed,
+  mergeDelta,
+  plainWhy,
+  readDeltas,
+  readKnowledgeApplies,
+  readNeeds,
+  readStageLoop,
+  setKnowledgeStatus,
+  stageComments,
+  stageGate
+} from "./chunk-KC5DROFC.js";
+import {
+  STAGE_PHASE,
+  fieldNames,
+  rerunOf
+} from "./chunk-RK6MKKKP.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  layerRules,
+  loadConstitution,
+  overrideStats,
+  readChangeFiles,
+  readPackFiles,
+  readProposals,
+  readRound,
+  readSnowDrafts,
+  readStoryIndex,
+  reviewedGates,
+  roundsOf
+} from "./chunk-47QE246J.js";
+import {
+  artifactFiles,
+  artifactPhase,
+  changeFolder,
+  changeReport,
+  changeSize,
+  changeStore,
+  detectConflicts,
+  liveHandoff,
+  loadChangeContext,
+  requiredArtifacts
+} from "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import {
+  fileStepStore,
+  manualAdapter,
+  stepOfProvisional
+} from "./chunk-NGPU2ARF.js";
+import {
+  componentRenames,
+  estateFacts,
+  estateJoinOf,
+  forgetCatalogs,
+  hostAliases,
+  joinReposOf,
+  keepCatalogsInMemory,
+  outsideProfileSystems,
+  readCatalog
+} from "./chunk-AY2IUF4K.js";
+import {
+  OrgPackProposal,
+  SNAPSHOT_FILE,
+  SnapshotManifest,
+  acceptOrgPackDraft,
+  correctableFields,
+  draftOrgPack,
+  filterItems,
+  itemTitle,
+  keepCandidate,
+  readConflicts,
+  readFind,
+  readFinds,
+  readKnowledge,
+  readReviews,
+  readSnapshot,
+  readSourceSettings,
+  reviewItem,
+  scopeWords,
+  searchPages,
+  snapshotDates,
+  snapshotSources,
+  writeReview
+} from "./chunk-6JLPXDWN.js";
+import {
+  NoSuchNode,
+  buildEstate,
+  focusView,
+  nodeView,
+  viewKey
+} from "./chunk-4GZXS6S2.js";
+import {
+  readServiceRequestExports,
+  readVendorSpec,
+  readWorkItemExports
+} from "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-CHC5FKTU.js";
+import "./chunk-7F2RUWPU.js";
+import {
+  readChangeRepos
+} from "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import {
+  COMMON_SETTINGS,
+  PROVIDER_SETTINGS,
+  defaultKeyStore,
+  looksLikeKey
+} from "./chunk-6EDQE7GO.js";
+import {
+  providerFactoryFor
+} from "./chunk-5XDNUJ4P.js";
+import {
+  ASSISTANTS,
+  ChangeArtifact,
+  DEFAULT_PORT,
+  DEFAULT_RUNTIME,
+  DiagramLayout,
+  KNOWLEDGE_KINDS,
+  KNOWLEDGE_RECORD_KIND,
+  LAYOUT_SCHEMA_VERSION,
+  MANUAL_SYSTEMS,
+  QuestionError,
+  QuestionState,
+  RUN_SCHEMA_VERSION,
+  RecordId,
+  Runtime,
+  SOURCE_KIND_SUGGESTIONS,
+  ViewKey,
+  acceptProposal,
+  answerQuestion,
+  api_exports,
+  catalogDirOf,
+  changesDirOf,
+  changesRelOf,
+  external_exports,
+  factIdPart,
+  factsRelOf,
+  gateRoundLimit,
+  inputsDirOf,
+  joinConventions,
+  joinSharedMaps,
+  joinVendorOperations,
+  knowledgeDirOf,
+  knowledgeKindOf,
+  knowledgeRelOf,
+  layoutPath,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  pageStanding,
+  proposalsDirOf,
+  proposalsRelOf,
+  readEstateJoins,
+  readQuestion,
+  readRepoSpec,
+  readSharedMaps,
+  require_dist,
+  runsDirOf,
+  runsRelOf,
+  specRelOf,
+  specRepos
+} from "./chunk-577AJVRS.js";
+import {
+  createLog,
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/ui-commands.js
+import { spawn } from "node:child_process";
+import { isAbsolute, join as join11, relative as relative2, sep as sep2 } from "node:path";
+
+// packages/ui/dist-lib/index.js
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var __atticus_import_meta_url = __atticusUrl("packages/ui/dist-lib/index.js");
+function uiDistDir() {
+  return join(dirname(fileURLToPath(__atticus_import_meta_url)), "..", "dist");
+}
+
+// packages/cli/dist/ui-api.js
+import { createHash } from "node:crypto";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+async function run(f) {
+  const out = [];
+  const err = [];
+  const code = await f({ out: (l) => out.push(l), err: (l) => err.push(l) });
+  return { code, out, err };
+}
+function refused(r) {
+  const detail = (r.err.length ? r.err : r.out).join("\n") || "The command refused.";
+  return r.code === 2 ? new HttpError(400, "The request isn't valid", detail) : new HttpError(422, "Atticus can't do that yet", detail, { lines: [...r.out, ...r.err] });
+}
+function parseBody(schema, body) {
+  const r = schema.safeParse(body ?? {});
+  if (!r.success)
+    throw badRequest("Some fields aren't right.", {
+      errors: r.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+    });
+  return r.data;
+}
+var sha = (s) => createHash("sha256").update(s).digest("hex");
+var MAX_ATTACH = 15 * 1024 * 1024;
+var NewChange = api_exports.NewChangeRequest;
+async function latestFindings(root, change) {
+  const out = [];
+  for (const gate of await reviewedGates(root, change)) {
+    const rounds = await roundsOf(root, change, gate);
+    if (rounds.length)
+      out.push(...(await readRound(root, change, gate, rounds.at(-1))).findings.map((f) => f.finding));
+  }
+  return out;
+}
+async function readChange(root, id) {
+  try {
+    return await changeStore(root).read(id);
+  } catch {
+    throw notFound(`There is no change ${id}.`);
+  }
+}
+async function changeDetail(root, id) {
+  const c = await readChange(root, id);
+  const report = await changeReport(root, id);
+  const findings = await latestFindings(root, id);
+  const open = { blocking: 0, gap: 0, risk: 0, idea: 0 };
+  for (const f of findings)
+    if (f.state === "open")
+      open[f.severity] += 1;
+  const dir = join2(changesDirOf(root), id);
+  const phases = report.type.phases;
+  const current = report.phase ? phases.indexOf(report.phase) : phases.length;
+  const artifacts = [];
+  const blockedArtifacts = new Set(report.blockers.map((b) => b.artifact).filter(Boolean));
+  const cctx = await loadChangeContext(root);
+  const onStages = (await Promise.all(cctx.policy.stages.map((s) => readFile(join2(dir, ...s.loop.split("/"))).then(() => true, () => false)))).some(Boolean);
+  const type = report.type.artifacts;
+  const ofStages = cctx.policy.stages.flatMap((s) => s.artifacts).filter((a, i, all) => type.includes(a) && all.indexOf(a) === i);
+  const due = /* @__PURE__ */ new Set();
+  for (const p of phases)
+    for (const a of requiredArtifacts(cctx, report.type, p, report.footprint))
+      due.add(a);
+  const order = onStages ? [...ofStages, ...type.filter((a) => !ofStages.includes(a))] : type;
+  for (const a of order) {
+    const files = await artifactFiles(dir, a);
+    if (onStages && !files.length && !(ofStages.includes(a) && due.has(a)))
+      continue;
+    const at = phases.indexOf(artifactPhase(cctx, report.type, a));
+    const done = files.length > 0 && !blockedArtifacts.has(a);
+    artifacts.push({
+      artifact: a,
+      path: `${changesRelOf(root)}/${id}/${files[0] ?? `${a}.md`}`,
+      status: done ? "done" : at <= current ? "ready" : "blocked",
+      openFindings: findings.filter((f) => f.state === "open" && f.artifact.startsWith(a)).length
+    });
+  }
+  const h = liveHandoff(c) ?? c.handoffs.at(-1);
+  const fast = (await changeSize(cctx, c)).fast;
+  return {
+    id: c.id,
+    title: c.title,
+    type: c.type,
+    state: c.state,
+    repos: c.touches.repos,
+    openFindings: open,
+    updatedAt: c.history.at(-1)?.at ?? c.createdAt,
+    ...fast ? { fastPath: true } : {},
+    artifacts,
+    ...h ? {
+      handoff: {
+        phase: h.phase,
+        ...h.pr?.url ? { pr: h.pr.url } : {},
+        state: h.state === "merged" ? "merged" : h.state === "closed" ? "closed" : "open"
+      }
+    } : {}
+  };
+}
+async function runView(root, change, runId) {
+  const dir = join2(runsDirOf(root), change, runId);
+  const text = await readFile(join2(dir, "run.json"), "utf8").catch(() => void 0);
+  if (!text)
+    return void 0;
+  const r = JSON.parse(text);
+  const manifest = await readFile(join2(dir, "context-manifest.json"), "utf8").catch(() => "");
+  return {
+    schemaVersion: RUN_SCHEMA_VERSION,
+    runId: r.runId,
+    change: r.request.change,
+    // A run records the whole agent definition; the view names it.
+    agent: typeof r.request.agent === "string" ? r.request.agent : r.request.agent.id,
+    runtime: r.runtime,
+    state: r.state,
+    startedAt: r.startedAt,
+    ...r.finishedAt ? { finishedAt: r.finishedAt } : {},
+    ...r.request.outputPath ? { output: r.request.outputPath } : {},
+    contextManifestSha256: sha(manifest),
+    errors: r.errors ?? [],
+    attempt: r.attempt ?? 1,
+    ...r.stepClass ? { stepClass: r.stepClass } : {},
+    ...r.model ? { model: r.model } : {},
+    promptPath: `${runsRelOf(root)}/${change}/${runId}/prompt.md`
+  };
+}
+async function findRun(root, runId) {
+  if (!/^run-[0-9a-z-]+$/.test(runId))
+    throw notFound(`There is no run ${runId}.`);
+  for (const change of await readdir(runsDirOf(root)).catch(() => [])) {
+    const v = await runView(root, change, runId);
+    if (v)
+      return v;
+  }
+  throw notFound(`There is no run ${runId}.`);
+}
+async function artifactPath(root, id, artifact) {
+  const a = ChangeArtifact.safeParse(artifact);
+  if (!a.success)
+    throw badRequest(`${artifact} is not an artifact. Use one of ${ChangeArtifact.options.join(", ")}.`);
+  const dir = join2(changesDirOf(root), id);
+  const files = await artifactFiles(dir, a.data);
+  if (files.length === 0)
+    throw notFound(`Change ${id} has no ${artifact} yet.`);
+  return files[0];
+}
+function uiRoutes(r, ctx, deps = {}) {
+  const { root, user, jobs } = ctx;
+  const changeDeps = {
+    ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+    ...deps.now ? { now: deps.now } : {}
+  };
+  return r.add("POST", "/api/changes", async ({ body }) => {
+    const b = parseBody(NewChange, body);
+    const owners = Object.entries(b.owners ?? {}).map(([role, who]) => `${role}=${who.join(",")}`);
+    const res = await run((io) => changeNew(root, {
+      id: b.id,
+      title: b.title,
+      type: b.type,
+      by: user,
+      owners,
+      ...b.systems ? { systems: b.systems } : {},
+      ...b.template ? { template: b.template } : {},
+      ...b.like ? { like: b.like } : {}
+    }, io, changeDeps));
+    if (res.code !== 0) {
+      if (res.err.some((l) => /already exists/i.test(l)))
+        throw conflict(res.err.join("\n"));
+      throw refused(res);
+    }
+    return { status: 201, body: await changeDetail(root, b.id) };
+  }).add("GET", "/api/changes/{changeId}", async ({ params }) => ({
+    status: 200,
+    body: await changeDetail(root, params.changeId)
+  })).add("GET", "/api/changes/{changeId}/status", async ({ params }) => {
+    await readChange(root, params.changeId);
+    const rep = await changeReport(root, params.changeId);
+    return {
+      status: 200,
+      body: {
+        state: rep.state,
+        ...rep.phase ? { phase: rep.phase } : {},
+        ...rep.next ? { next: rep.next } : {},
+        ...rep.progress ? { progress: rep.progress } : {},
+        nextStep: rep.nextStep,
+        risk: rep.risk,
+        tests: rep.tests,
+        ...rep.handoff ? {
+          handoff: {
+            pr: rep.handoff.pr,
+            state: rep.handoff.state,
+            phase: rep.handoff.phase
+          }
+        } : {},
+        blockers: rep.blockers,
+        reasons: rep.reasons
+      }
+    };
+  }).add("GET", "/api/changes/{changeId}/artifacts/{artifact}", async ({ params }) => {
+    await readChange(root, params.changeId);
+    const rel = await artifactPath(root, params.changeId, params.artifact);
+    const content = await readFile(join2(changesDirOf(root), params.changeId, rel), "utf8");
+    return {
+      status: 200,
+      body: {
+        artifact: params.artifact,
+        path: `${changesRelOf(root)}/${params.changeId}/${rel}`,
+        content,
+        sha256: sha(content)
+      }
+    };
+  }).add("PUT", "/api/changes/{changeId}/artifacts/{artifact}", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.SaveArtifactRequest, body);
+    const rel = await artifactPath(root, params.changeId, params.artifact);
+    const file = join2(changesDirOf(root), params.changeId, rel);
+    const now = await readFile(file, "utf8");
+    if (sha(now) !== b.baseSha256)
+      throw conflict(`${rel} changed since you opened it. Reload it, then make your edit again.`);
+    await writeFile(file, b.content, "utf8");
+    ctx.events.publish({
+      type: "file.changed",
+      path: `${changesRelOf(root)}/${params.changeId}/${rel}`
+    });
+    return {
+      status: 200,
+      body: {
+        artifact: params.artifact,
+        path: `${changesRelOf(root)}/${params.changeId}/${rel}`,
+        content: b.content,
+        sha256: sha(b.content)
+      }
+    };
+  }).add("GET", "/api/changes/{changeId}/tasks", async ({ params }) => {
+    await readChange(root, params.changeId);
+    const files = await readChangeFiles(join2(changesDirOf(root), params.changeId));
+    return {
+      status: 200,
+      body: readChangeTasks(files).map((t) => ({
+        id: t.id,
+        repo: t.repo,
+        description: t.title,
+        done: t.done,
+        ...t.stories[0] ? { story: t.stories[0] } : {},
+        branch: `task/${params.changeId}/${t.id}`
+      }))
+    };
+  }).add("POST", "/api/changes/{changeId}/workspace", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.OpenWorkspaceRequest, body);
+    const res = await run((io) => workspaceOpen(root, params.changeId, b.repos, io));
+    if (res.code !== 0)
+      throw refused(res);
+    const repos = await readFile(join2(changesDirOf(root), params.changeId, "repos.yaml"), "utf8").catch(() => "");
+    return { status: 200, body: { lines: res.out, reposYaml: repos } };
+  }).add("POST", "/api/changes/{changeId}/handoff", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.HandoffRequest, body);
+    const res = await run((io) => changeHandoff(root, params.changeId, { by: user, approve: true, ...b.repo ? { repo: b.repo } : {} }, io, changeDeps));
+    if (res.code !== 0)
+      throw refused(res);
+    return { status: 201, body: await changeDetail(root, params.changeId) };
+  }).add("POST", "/api/changes/{changeId}/sync", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.SyncRequest, body);
+    const res = await run((io) => changeSync(root, params.changeId, { by: user, approve: true, ...b.repo ? { repo: b.repo } : {} }, io, changeDeps));
+    if (res.code === 2)
+      throw refused(res);
+    return {
+      status: 200,
+      body: {
+        ...await changeDetail(root, params.changeId),
+        lines: [...res.out, ...res.err]
+      }
+    };
+  }).add("GET", "/api/changes/{changeId}/inputs", async ({ params }) => {
+    const c = await readChange(root, params.changeId);
+    const { readChangeInputs } = await import("./chunk-FOGG4AUR.js");
+    return {
+      status: 200,
+      body: api_exports.ChangeInputList.parse(await readChangeInputs(join2(changesDirOf(root), c.id)))
+    };
+  }).add("GET", "/api/changes/{changeId}/prototypes", async ({ params }) => {
+    const c = await readChange(root, params.changeId);
+    const { changePrototypes } = await import("./chunk-LVGBKKSM.js");
+    return {
+      status: 200,
+      body: api_exports.ChangePrototypeList.parse(await changePrototypes(root, c.id))
+    };
+  }).add("POST", "/api/changes/{changeId}/inputs", async ({ params, body }) => {
+    const c = await readChange(root, params.changeId);
+    const b = parseBody(api_exports.AttachFileRequest, body);
+    const bytes = new Uint8Array(Buffer.from(b.content, "base64"));
+    if (bytes.length > MAX_ATTACH)
+      throw new HttpError(413, "The file is too large", "Attach a file of 15 MB or less.");
+    const { attachFiles } = await import("./chunk-Y7KBQ4BD.js");
+    const r2 = await attachFiles(root, c.id, [{ name: b.name, bytes }], user);
+    if (!r2.added.length)
+      throw new HttpError(422, "Atticus can't attach that", r2.refused[0]?.why ?? "", {
+        lines: r2.refused.map((x) => `${x.name}: ${x.why}`)
+      });
+    return { status: 201, body: api_exports.AttachResult.parse(r2) };
+  }, { maxBody: Math.ceil(MAX_ATTACH * 4 / 3) + 64 * 1024 }).add("GET", "/api/changes/{changeId}/runs", async ({ params }) => {
+    await readChange(root, params.changeId);
+    const dir = join2(runsDirOf(root), params.changeId);
+    const out = [];
+    for (const id of (await readdir(dir).catch(() => [])).sort()) {
+      const v = await runView(root, params.changeId, id);
+      if (v)
+        out.push(v);
+    }
+    return { status: 200, body: out };
+  }).add("POST", "/api/changes/{changeId}/runs", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.StartRunRequest, body);
+    const before = new Set(await readdir(join2(runsDirOf(root), params.changeId)).catch(() => []));
+    let res;
+    if (b.task)
+      res = await run((io) => taskRun(root, params.changeId, b.task, {
+        mode: b.runtime,
+        by: user,
+        ...b.autonomy ? {
+          level: b.autonomy === "draft-and-pr" ? "pr" : b.autonomy === "plan-only" ? "plan" : "draft"
+        } : {}
+      }, io));
+    else if (b.agent === "story-writer")
+      res = await run((io) => planStories(root, params.changeId, { mode: b.runtime }, io));
+    else if (b.agent.endsWith("-critic"))
+      res = await run((io) => critic(root, params.changeId, { mode: b.runtime }, io));
+    else
+      throw badRequest(`Start ${b.agent} from its screen; this call starts task runs, the story writer and the critic.`);
+    if (res.code === 2)
+      throw refused(res);
+    const after = (await readdir(join2(runsDirOf(root), params.changeId)).catch(() => [])).filter((x) => !before.has(x)).sort();
+    if (after.length === 0)
+      throw refused(res);
+    const v = await runView(root, params.changeId, after.at(-1));
+    for (const id of after)
+      ctx.events.publish({
+        type: "run.changed",
+        runId: id,
+        state: (await runView(root, params.changeId, id))?.state ?? "prepared"
+      });
+    return { status: 201, body: v };
+  }).add("POST", "/api/changes/{changeId}/critic", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.RunCriticRequest, body);
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const mode = op.runtime.ai === "off" ? void 0 : "hand-off";
+    const once = (gate) => run((io) => critic(root, params.changeId, { ...gate ? { gate } : {}, ...mode ? { mode } : {}, json: true }, io));
+    let res = await once(b.gate);
+    if (!b.gate && res.code === 2 && res.err.some((l) => /has no gate/.test(l))) {
+      const next = (await changeReport(root, params.changeId)).next;
+      if (next)
+        res = await once(next);
+    }
+    if (res.code === 2)
+      throw refused(res);
+    ctx.events.publish({
+      type: "file.changed",
+      path: `${changesRelOf(root)}/${params.changeId}/review`
+    });
+    let round;
+    try {
+      round = JSON.parse(res.out.join("\n"));
+    } catch {
+      throw refused(res);
+    }
+    return { status: 200, body: { ai: op.runtime.ai, round } };
+  }).add("GET", "/api/runs/{runId}", async ({ params }) => ({
+    status: 200,
+    body: await findRun(root, params.runId)
+  })).add("POST", "/api/runs/{runId}/done", async ({ params }) => {
+    const before = await findRun(root, params.runId);
+    if (before.state === "validated" || before.state === "cancelled")
+      throw conflict(`Run ${params.runId} is already ${before.state}.`);
+    const res = await run((io) => handoffDone(root, params.runId, io));
+    const after = await findRun(root, params.runId);
+    ctx.events.publish({ type: "run.changed", runId: after.runId, state: after.state });
+    return { status: 200, body: { ...after, lines: [...res.out, ...res.err] } };
+  }).add("POST", "/api/runs/{runId}/retry", async ({ params }) => {
+    const v = await findRun(root, params.runId);
+    if (v.state !== "failed")
+      throw conflict(`Only a failed run can be retried; ${v.runId} is ${v.state}.`);
+    const file = join2(runsDirOf(root), v.change, v.runId, "run.json");
+    const rec = JSON.parse(await readFile(file, "utf8"));
+    rec.state = "prepared";
+    rec.attempt = (rec.attempt ?? 1) + 1;
+    rec.errors = [];
+    await writeFile(file, JSON.stringify(rec, null, 2) + "\n");
+    const after = await findRun(root, params.runId);
+    ctx.events.publish({ type: "run.changed", runId: after.runId, state: after.state });
+    return { status: 200, body: after };
+  }).add("POST", "/api/runs/{runId}/cancel", async ({ params }) => {
+    const v = await findRun(root, params.runId);
+    if (["validated", "cancelled"].includes(v.state))
+      throw conflict(`Run ${v.runId} is already ${v.state}.`);
+    const file = join2(runsDirOf(root), v.change, v.runId, "run.json");
+    const rec = JSON.parse(await readFile(file, "utf8"));
+    rec.state = "cancelled";
+    rec.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeFile(file, JSON.stringify(rec, null, 2) + "\n");
+    const after = await findRun(root, params.runId);
+    ctx.events.publish({ type: "run.changed", runId: after.runId, state: after.state });
+    return { status: 200, body: after };
+  }).add("POST", "/api/findings/{changeId}/{findingId}/action", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.FindingActionRequest, body);
+    const res = await run((io) => findingAction(root, params.changeId, params.findingId, b.action, {
+      by: user,
+      ...b.reason ? { reason: b.reason } : {},
+      ...b.askedOf ? { askedOf: b.askedOf } : {},
+      ...b.patch ? { edit: b.patch } : {},
+      ...b.gate ? { gate: b.gate } : {}
+    }, io));
+    if (res.code !== 0) {
+      if (res.err.some((l) => /no finding|not found/i.test(l)))
+        throw notFound(res.err.join("\n"));
+      if (res.err.some((l) => /can't be waived|not allowed|needs/i.test(l)))
+        throw new HttpError(403, "Not allowed", res.err.join("\n"));
+      throw refused(res);
+    }
+    const f = (await latestFindings(root, params.changeId)).find((x) => x.id === params.findingId);
+    return { status: 200, body: f };
+  }).add("POST", "/api/scan", ({ body }) => {
+    const b = parseBody(api_exports.ScanRequest, body);
+    if (jobs.runningOf("scan"))
+      throw conflict("A scan is already running.");
+    const job = jobs.start("scan", async (c) => {
+      c.progress(0, 1, "Scanning");
+      const res = await run((io) => scanCommand(root, {
+        ...b.repos ? { repos: b.repos } : {},
+        full: b.full,
+        json: true,
+        // ADR 0123: another branch, scanned beside the baseline.
+        ...b.ref ? { ref: b.ref } : {}
+      }, io));
+      c.progress(1, 1, "Scanned");
+      const parsed = (() => {
+        try {
+          return JSON.parse(res.out.join("\n"));
+        } catch {
+          return {};
+        }
+      })();
+      const problems = parsed.problems?.length ?? 0;
+      ctx.events.publish({
+        type: "index.rebuilt",
+        records: Number(parsed.stats?.records ?? 0)
+      });
+      return {
+        result: { stats: parsed.stats, problems },
+        errors: res.code === 2 ? res.err : []
+      };
+    });
+    return { status: 202, body: { jobId: job.id } };
+  }).add("POST", "/api/workspace/sync", ({ body }) => {
+    const b = parseBody(api_exports.ScanRequest.pick({ repos: true }), body);
+    const job = jobs.start("sync", async (c) => {
+      c.progress(0, 1, "Syncing base clones");
+      const res = await run((io) => workspaceSync(root, b.repos, io));
+      c.progress(1, 1, "Synced");
+      return { result: { lines: res.out }, errors: res.code === 0 ? [] : res.err };
+    });
+    return { status: 202, body: { jobId: job.id } };
+  }).add("POST", "/api/reconcile", ({ body }) => {
+    const b = parseBody(api_exports.ReconcileRequest, body);
+    const job = jobs.start("reconcile", async (c) => {
+      c.progress(0, 1, `Reconciling ${b.diagram}`);
+      const res = await run((io) => reconcileCommand(root, [b.diagram], { json: true }, io));
+      c.progress(1, 1, "Reconciled");
+      let result;
+      try {
+        result = JSON.parse(res.out.join("\n"));
+      } catch {
+        result = { lines: res.out };
+      }
+      return { result, errors: res.code === 2 ? res.err : [] };
+    });
+    return { status: 202, body: { jobId: job.id } };
+  });
+}
+
+// packages/cli/dist/ui-api-run.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir as readdir2, readFile as readFile2, stat } from "node:fs/promises";
+import { join as join3, resolve } from "node:path";
+async function run2(f) {
+  const out = [];
+  const err = [];
+  const code = await f({ out: (l) => out.push(l), err: (l) => err.push(l) });
+  return { code, out, err };
+}
+function refused2(r) {
+  const detail = (r.err.length ? r.err : r.out).join("\n") || "The command refused.";
+  return r.code === 2 ? new HttpError(400, "The request isn't valid", detail) : new HttpError(422, "Atticus can't do that yet", detail, { lines: [...r.out, ...r.err] });
+}
+function parseBody2(schema, body) {
+  const r = schema.safeParse(body ?? {});
+  if (!r.success)
+    throw badRequest("Some fields aren't right.", {
+      errors: r.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+    });
+  return r.data;
+}
+function jsonOf(r) {
+  const text = r.out.join("\n").trim();
+  if (!text.startsWith("{") && !text.startsWith("["))
+    return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function viewOf(r) {
+  const out = r.code === 0 ? jsonOf(r) : void 0;
+  if (out !== void 0)
+    return out;
+  if (r.err.some((l) => /^There is no change/.test(l)))
+    throw notFound(r.err.join("\n"));
+  throw refused2(r.code === 0 ? { ...r, code: 1 } : r);
+}
+async function readChange2(root, id) {
+  try {
+    return await changeStore(root).read(id);
+  } catch {
+    throw notFound(`There is no change ${id}.`);
+  }
+}
+async function openChanges2(root) {
+  return (await changeStore(root).list()).filter((c) => c.state !== "archived").sort((a, b) => a.id.localeCompare(b.id));
+}
+async function latestFindings2(root, change) {
+  const out = [];
+  for (const gate of await reviewedGates(root, change)) {
+    const rounds = await roundsOf(root, change, gate);
+    if (rounds.length)
+      out.push(...(await readRound(root, change, gate, rounds.at(-1))).findings.map((f) => f.finding));
+  }
+  return out;
+}
+async function filesUnder(dir, prefix = "") {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const rel = prefix ? `${prefix}/${e.name}` : e.name;
+    if (e.isDirectory())
+      out.push(...await filesUnder(join3(dir, e.name), rel));
+    else
+      out.push({ path: rel, bytes: (await stat(join3(dir, e.name))).size });
+  }
+  return out;
+}
+var RUNTIME_KIND = {
+  "work-tracker": "workTracker",
+  "service-desk": "serviceDesk",
+  "git-host": "gitHost",
+  wiki: "wiki",
+  notify: "notify",
+  design: "design"
+};
+async function executorsOf(root, deps) {
+  return deps.todo?.executors ? { executors: deps.todo.executors, problems: [] } : await loadExecutors(root);
+}
+var stepRef = (id, change) => change ? `${change}/${id}` : id;
+function stepView(s, all, pack, configured) {
+  const proc = s.procedure ? pack.procedures.find((p) => p.id === s.procedure) : void 0;
+  return {
+    id: s.id,
+    ...s.change ? { change: s.change } : {},
+    system: s.system,
+    action: s.action,
+    state: s.state,
+    title: s.title,
+    where: s.where,
+    ...s.procedure ? { procedure: s.procedure } : {},
+    ...s.procedureStep ? { procedureStep: s.procedureStep } : {},
+    fields: s.fields.map((f) => ({
+      name: f.name,
+      value: f.value,
+      ...f.help ? { help: f.help } : {}
+    })),
+    instructions: s.instructions,
+    result: s.result,
+    waitsFor: s.dependsOn.filter((d) => all.find((x) => x.id === d)?.state === "open"),
+    ...s.reason ? { reason: s.reason } : {},
+    ...s.recorded ? { recorded: s.recorded } : {},
+    runs: s.runs.map((r) => ({
+      runId: r.runId,
+      executor: r.executor,
+      at: r.at,
+      status: r.status,
+      mode: r.mode,
+      by: r.approval.by,
+      ...r.message ? { message: r.message } : {}
+    })),
+    /** Executors that may do this step: the procedure allows them and this person has them. */
+    executors: (proc?.executors.allowed ?? []).filter((n) => configured.has(n)),
+    createdAt: s.createdAt,
+    createdBy: s.createdBy
+  };
+}
+async function findStep(root, id, change) {
+  const all = await fileStepStore(root).list(change ? { change } : {});
+  const s = all.find((x) => x.id === id);
+  if (!s)
+    throw notFound(`There is no step ${stepRef(id, change)}.`);
+  return s;
+}
+var SyncEntries = external_exports.object({
+  requests: external_exports.array(external_exports.object({ key: external_exports.string(), id: external_exports.string() })).default([])
+});
+async function changeRequests(root, change, templates, steps) {
+  const dir = changeFolder(root, change);
+  const drafts = readSnowDrafts(await readChangeFiles(dir));
+  if (drafts.length === 0)
+    return [];
+  let synced = [];
+  try {
+    synced = SyncEntries.parse((0, import_yaml.parse)(await readFile2(join3(dir, SYNC_FILE), "utf8"))).requests;
+  } catch {
+  }
+  return drafts.map((d) => {
+    const h = d.heading.toLowerCase();
+    const t = templates.find((x) => [x.requestType, x.name, x.id].some((n) => h.includes(n.toLowerCase())));
+    const record = /:\s*(\S+)\s*$/.exec(d.heading)?.[1] ?? "";
+    const fields = t ? t.fields.map((f) => ({
+      name: f.name,
+      value: d.fields.get(f.name.toLowerCase())?.value ?? "",
+      required: f.required
+    })) : [...d.fields].map(([name, v2]) => ({ name, value: v2.value, required: false }));
+    const base = {
+      change,
+      heading: d.heading,
+      ...t ? { template: t.id, leadTimeDays: t.leadTimeDays } : {},
+      requestType: t?.requestType ?? d.heading,
+      record,
+      approvers: t?.approvers ?? [],
+      fields,
+      missing: fields.filter((f) => f.required && !f.value.trim()).map((f) => f.name)
+    };
+    const entry = t ? synced.find((e) => e.key === `${t.id}|${record}`) : void 0;
+    if (!entry)
+      return { ...base, state: "to-file" };
+    const stepId = stepOfProvisional(entry.id);
+    if (!stepId)
+      return { ...base, state: "filed", number: entry.id };
+    const s = steps.find((x) => x.id === stepId);
+    const v = s?.state === "done" ? s.recorded?.values : void 0;
+    return typeof v?.requestNumber === "string" ? {
+      ...base,
+      state: "filed",
+      step: stepId,
+      number: v.requestNumber,
+      ...typeof v.url === "string" ? { url: v.url } : {}
+    } : { ...base, state: "waiting", step: stepId };
+  });
+}
+function questionOf(check) {
+  if (check.type === "answer")
+    return check.question;
+  if (check.type === "all") {
+    for (const c of check.checks)
+      if (c.type === "answer")
+        return c.question;
+  }
+  return void 0;
+}
+var commandLine = (argv) => `atticus ${argv.map((a) => /[\s"']/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a).join(" ")}`;
+function stepOfLesson(l, id) {
+  const s = l.steps.find((x) => x.id === id);
+  if (!s)
+    return void 0;
+  const q = questionOf(s.check);
+  return {
+    id: s.id,
+    n: l.steps.indexOf(s) + 1,
+    title: s.title,
+    body: s.body,
+    commands: s.do.map(commandLine),
+    ...q ? { question: q } : {},
+    hint: s.hint
+  };
+}
+var ALL = /* @__PURE__ */ new Set(["1", "true", "yes"]);
+function uiRunRoutes(r, ctx, deps = {}) {
+  const { root, user } = ctx;
+  const nowDate = deps.now ? () => new Date(deps.now) : void 0;
+  const pack = () => loadOrgPack(orgPackDirOf(root));
+  const rel = deps.now ? { now: () => new Date(deps.now) } : {};
+  return r.add("GET", "/api/todo", async ({ query }) => {
+    const change = strParam(query, "change");
+    const op = await pack();
+    let steps;
+    try {
+      steps = await fileStepStore(root).list(change ? { change } : {});
+    } catch (e) {
+      throw new HttpError(422, "A step file can't be read", e.message);
+    }
+    const all = ALL.has(strParam(query, "all") ?? "");
+    const ex = await executorsOf(root, deps);
+    const configured = new Set(ex.executors.map((e) => e.name));
+    const inputs = { root, inputsDir: inputsDirOf(root) };
+    const [items, requests] = await Promise.all([
+      readWorkItemExports(inputs),
+      readServiceRequestExports(inputs)
+    ]);
+    return {
+      status: 200,
+      body: {
+        steps: steps.filter((s) => all || s.state === "open").map((s) => stepView(s, steps, op, configured)),
+        sources: MANUAL_SYSTEMS.map((system) => ({
+          system,
+          configured: op.runtime.adapters[RUNTIME_KIND[system]]?.type ?? null,
+          open: steps.filter((s) => s.system === system && s.state === "open").length
+        })),
+        exports: {
+          workItems: items.items.length,
+          requests: requests.requests.length,
+          files: [.../* @__PURE__ */ new Set([...items.files, ...requests.files])].sort()
+        },
+        procedures: op.procedures.map((p) => {
+          const runs = steps.filter((s) => s.procedure === p.id).flatMap((s) => s.runs).sort((a, b) => a.at < b.at ? -1 : 1);
+          const last = runs.at(-1);
+          return {
+            id: p.id,
+            name: p.name,
+            system: p.system,
+            status: p.status,
+            steps: p.steps.length,
+            writes: p.steps.filter((s) => s.writes).length,
+            allowed: p.executors.allowed,
+            configured: p.executors.allowed.filter((n) => configured.has(n)),
+            runs: runs.length,
+            ...last ? { lastRun: { at: last.at, status: last.status, executor: last.executor } } : {}
+          };
+        }),
+        executors: { configured: [...configured].sort(), problems: ex.problems }
+      }
+    };
+  }).add("GET", "/api/todo/{stepId}/export", async ({ params, query }) => {
+    const format = strParam(query, "format") ?? "text";
+    const res = await run2((io) => todoShow(root, stepRef(params.stepId, strParam(query, "change")), { export: format }, io));
+    if (res.code === 0)
+      return { status: 200, body: { format, text: res.out.join("\n") } };
+    if (res.err.some((l) => /^There is no step/.test(l)))
+      throw notFound(res.err.join("\n"));
+    throw refused2(res);
+  }).add("POST", "/api/todo/{stepId}/done", async ({ params, body }) => {
+    const b = parseBody2(api_exports.StepDoneRequest, body);
+    const ref = stepRef(params.stepId, b.change);
+    const res = await run2((io) => todoDone(root, ref, {
+      by: user,
+      result: b.values,
+      ...b.skip ? { skip: true } : {},
+      ...b.note ? { note: b.note } : {}
+    }, io, deps.todo ?? {}));
+    if (res.code !== 0) {
+      if (res.err.some((l) => /^There is no step/.test(l)))
+        throw notFound(res.err.join("\n"));
+      throw refused2(res);
+    }
+    ctx.events.publish({ type: "file.changed", path: `steps/${params.stepId}` });
+    const s = await findStep(root, params.stepId, b.change);
+    return { status: 200, body: { ...s, lines: res.out } };
+  }).add("GET", "/api/todo/{stepId}/run", async ({ params, query }) => {
+    const s = await findStep(root, params.stepId, strParam(query, "change"));
+    const op = await pack();
+    const proc = s.procedure ? op.procedures.find((p) => p.id === s.procedure) : void 0;
+    const configured = new Set((await executorsOf(root, deps)).executors.map((e) => e.name));
+    const allowed = (proc?.executors.allowed ?? []).filter((n) => configured.has(n));
+    const want = strParam(query, "with");
+    const step = proc?.steps.find((x) => x.id === s.procedureStep);
+    return {
+      status: 200,
+      body: {
+        step: s.id,
+        inputs: s.inputs,
+        inputsSha256: inputsSha256(s.inputs),
+        executors: allowed,
+        ...want ? { allowed: allowed.includes(want) } : {},
+        writes: step?.writes ?? false,
+        ...proc ? { procedure: proc.id } : {}
+      }
+    };
+  }).add("POST", "/api/todo/{stepId}/run", async ({ params, body }) => {
+    const b = parseBody2(api_exports.StepRunRequest, body);
+    const res = await run2((io) => todoRun(root, stepRef(params.stepId, b.change), {
+      with: b.with,
+      approve: user,
+      inputs: b.inputsSha256,
+      ...b.fillOnly ? { fillOnly: true } : {}
+    }, io, deps.todo ?? {}));
+    if (res.code !== 0) {
+      if (res.err.some((l) => /^There is no step/.test(l)))
+        throw notFound(res.err.join("\n"));
+      throw refused2(res);
+    }
+    ctx.events.publish({ type: "file.changed", path: `steps/${params.stepId}` });
+    return {
+      status: 200,
+      body: { step: await findStep(root, params.stepId, b.change), lines: res.out }
+    };
+  }).add("GET", "/api/service-desk", async ({ query }) => {
+    const only = strParam(query, "change");
+    const op = await pack();
+    const steps = await fileStepStore(root).list({ system: "service-desk" }).catch(() => []);
+    const requests = [];
+    for (const c of await openChanges2(root))
+      if (!only || c.id === only)
+        requests.push(...await changeRequests(root, c.id, op.serviceRequests, steps));
+    const exported = await readServiceRequestExports({ root, inputsDir: inputsDirOf(root) });
+    const ex = await executorsOf(root, deps);
+    const configured = new Set(ex.executors.map((e) => e.name));
+    return {
+      status: 200,
+      body: {
+        adapter: { configured: op.runtime.adapters.serviceDesk?.type ?? null },
+        exports: { requests: exported.requests.length, files: exported.files },
+        templates: op.serviceRequests.map((t) => ({
+          id: t.id,
+          name: t.name,
+          requestType: t.requestType,
+          leadTimeDays: t.leadTimeDays
+        })),
+        executors: op.procedures.filter((p) => p.system === "service-desk").flatMap((p) => p.executors.allowed.filter((n) => configured.has(n))).filter((n, i, a) => a.indexOf(n) === i),
+        requests
+      }
+    };
+  }).add("POST", "/api/service-desk/{changeId}/draft", async ({ params, body }) => {
+    await readChange2(root, params.changeId);
+    const b = parseBody2(api_exports.DraftRequestsRequest, body);
+    const res = await run2((io) => snowDraft(root, params.changeId, b.force ? { force: true } : {}, io));
+    if (res.code !== 0 && (res.code !== 1 || res.err.length))
+      throw refused2(res);
+    ctx.events.publish({ type: "file.changed", path: `${params.changeId}/snow.md` });
+    return { status: 200, body: { lines: res.out, toFill: res.code === 1 } };
+  }).add("POST", "/api/service-desk/{changeId}/submit", async ({ params }) => {
+    await readChange2(root, params.changeId);
+    const op = await pack();
+    const desk = deps.serviceDesk ?? manualAdapter("serviceDesk", {
+      store: fileStepStore(root),
+      root,
+      change: params.changeId,
+      procedures: op.procedures,
+      ...deps.now ? { now: () => deps.now } : {}
+    }, op.runtime.adapters.serviceDesk?.settings ?? {});
+    const res = await run2((io) => snowSubmit(root, params.changeId, { approve: user }, io, {
+      serviceDesk: desk,
+      ...nowDate ? { now: nowDate } : {}
+    }));
+    if (res.code !== 0)
+      throw refused2(res);
+    ctx.events.publish({ type: "file.changed", path: `${params.changeId}/sync.yaml` });
+    return { status: 200, body: { lines: res.out } };
+  }).add("GET", "/api/release", async () => {
+    const at = /* @__PURE__ */ new Set(["release-ready", "released", "post-release-review"]);
+    const list = (await openChanges2(root)).map((c) => ({
+      id: c.id,
+      title: c.title,
+      type: c.type,
+      state: c.state,
+      atRelease: at.has(c.state)
+    }));
+    list.sort((a, b) => Number(b.atRelease) - Number(a.atRelease));
+    return { status: 200, body: list };
+  }).add("GET", "/api/release/{changeId}", async ({ params }) => {
+    const id = params.changeId;
+    const c = await readChange2(root, id);
+    const op = await pack();
+    const rep = await changeReport(root, id);
+    const findings = await latestFindings2(root, id);
+    const open = { blocking: 0, gap: 0, risk: 0, idea: 0 };
+    for (const f of findings)
+      if (f.state === "open")
+        open[f.severity] += 1;
+    const steps = await fileStepStore(root).list({ change: id }).catch(() => []);
+    const requests = await changeRequests(root, id, op.serviceRequests, steps);
+    const design = (await readChangeFiles(changeFolder(root, id))).docs.get("design.md");
+    const sec = design?.sections.find((s) => /rollout|rollback|release|deploy/i.test(s.heading));
+    const repos = (await readChangeRepos(root, id).catch(() => void 0))?.repos ?? [];
+    const conflicts = (await detectConflicts(root).catch(() => [])).filter((p) => p.changes.includes(id)).map((p) => ({ with: p.changes.find((x) => x !== id), overlap: p.overlap }));
+    const archive = await archiveGate(root, id).catch((e) => ({
+      pass: false,
+      blockers: [{ code: "error", message: e.message }],
+      notes: []
+    }));
+    const handoff = c.handoffs.filter((h) => h.phase === "release").at(-1);
+    return {
+      status: 200,
+      body: {
+        change: { id: c.id, title: c.title, type: c.type, state: c.state, owners: c.owners },
+        status: {
+          state: rep.state,
+          ...rep.phase ? { phase: rep.phase } : {},
+          ...rep.next ? { next: rep.next } : {},
+          nextStep: rep.nextStep,
+          risk: rep.risk,
+          blockers: rep.blockers,
+          reasons: rep.reasons
+        },
+        // Go / no-go is the release hand-off PR: merging it is the go (ADR 0073).
+        ...handoff ? {
+          handoff: {
+            state: handoff.state,
+            pr: handoff.pr.url,
+            approvals: handoff.approvals,
+            reviewers: handoff.reviewers
+          }
+        } : {},
+        openFindings: open,
+        requests: {
+          total: requests.length,
+          filed: requests.filter((x) => x.state !== "to-file").length,
+          toFile: requests.filter((x) => x.state === "to-file").length,
+          list: requests
+        },
+        repos: repos.map((x) => ({
+          id: x.id,
+          branch: x.branch,
+          ...x.pr ? { pr: x.pr } : {},
+          build: x.build
+        })),
+        ...sec && design ? {
+          rollout: {
+            heading: sec.heading,
+            text: design.lines.slice(sec.line, sec.end).join("\n").trim()
+          }
+        } : {},
+        conflicts,
+        archive: { pass: archive.pass, blockers: archive.blockers, notes: archive.notes },
+        evidence: await filesUnder(changeFolder(root, id))
+      }
+    };
+  }).add("POST", "/api/release/{changeId}/archive", async ({ params, body }) => {
+    const id = params.changeId;
+    await readChange2(root, id);
+    const b = parseBody2(api_exports.ArchiveRequest, body);
+    const gate = await run2((io) => ciArchiveGate(root, id, {}, io));
+    if (gate.code !== 0)
+      throw refused2(gate);
+    const res = await run2((io) => changeArchive(root, id, { by: user, ...b.rescan === false ? { rescan: false } : {} }, io));
+    if (res.code !== 0)
+      throw refused2(res);
+    ctx.events.publish({ type: "file.changed", path: id });
+    return { status: 200, body: { lines: [...gate.out, ...res.out] } };
+  }).add("GET", "/api/release/{changeId}/plan", async ({ params }) => ({
+    status: 200,
+    body: viewOf(await run2((io) => releasePlanCommand(root, params.changeId, { json: true }, io, rel)))
+  })).add("GET", "/api/release/{changeId}/forecast", async ({ params }) => ({
+    status: 200,
+    body: viewOf(await run2((io) => releaseForecastCommand(root, params.changeId, { json: true }, io, rel)))
+  })).add("GET", "/api/release/{changeId}/evidence", async ({ params }) => ({
+    status: 200,
+    body: viewOf(await run2((io) => releaseEvidenceCommand(root, params.changeId, { json: true }, io, rel)))
+  })).add("GET", "/api/release/{changeId}/notes", async ({ params, query }) => {
+    const audience = strParam(query, "audience") ?? "business";
+    return {
+      status: 200,
+      body: viewOf(await run2((io) => releaseNotesCommand(root, params.changeId, { audience, json: true }, io, rel)))
+    };
+  }).add("GET", "/api/release/{changeId}/security", async ({ params }) => ({
+    status: 200,
+    body: viewOf(await run2((io) => releaseSecurityCommand(root, params.changeId, { json: true }, io, rel)))
+  })).add("GET", "/api/outcomes", async ({ query }) => {
+    const change = strParam(query, "change");
+    return {
+      status: 200,
+      body: viewOf(await run2((io) => outcomeList(root, { ...change ? { change } : {}, json: true }, io, rel)))
+    };
+  }).add("POST", "/api/release/{changeId}/outcomes", async ({ params, body }) => {
+    const id = params.changeId;
+    await readChange2(root, id);
+    const b = parseBody2(api_exports.RecordOutcomeRequest, body);
+    const res = await run2((io) => outcomeRecord(root, id, b.measure, { value: b.value, by: user, ...b.note ? { note: b.note } : {}, json: true }, io, rel));
+    if (res.code !== 0)
+      throw refused2(res);
+    ctx.events.publish({ type: "file.changed", path: `${id}/review/outcomes.yaml` });
+    return { status: 200, body: jsonOf(res) ?? { lines: res.out } };
+  }).add("GET", "/api/governance", async () => {
+    const conf = jsonOf(await run2((io) => conformanceCommand(orgPackDirOf(root), { kind: "org-pack", json: true }, io)));
+    const constitution = await loadConstitution();
+    const org = await readPackFiles(root, join3(orgPackDirOf(root), "checklists"));
+    const team = await readPackFiles(root, join3(orgPackDirOf(root), "teams"));
+    const layered = layerRules([
+      { pack: constitution, file: "built-in", origin: "constitution" },
+      ...org.packs.map((p) => ({ ...p, origin: "org" })),
+      ...team.packs.map((p) => ({ ...p, origin: "team" }))
+    ]);
+    const changes = await openChanges2(root);
+    const waivers = [];
+    for (const c of changes) {
+      for (const f of await latestFindings2(root, c.id))
+        if (f.state === "waived")
+          waivers.push({
+            change: c.id,
+            gate: f.gate,
+            rule: f.rule,
+            summary: f.summary,
+            ...f.resolution ? { by: f.resolution.by, at: f.resolution.at, reason: f.resolution.reason } : {}
+          });
+    }
+    const stats = jsonOf(await run2((io) => criticStats(root, { json: true }, io)));
+    const count = (packs) => packs.reduce((a, p) => a + p.pack.rules.length, 0);
+    return {
+      status: 200,
+      body: {
+        conformance: conf ? { ...conf, target: "org-pack" } : {
+          kind: "org-pack",
+          passed: false,
+          results: [],
+          summary: { pass: 0, fail: 0, warn: 0 }
+        },
+        rules: {
+          constitution: constitution.rules.length,
+          org: count(org.packs),
+          team: count(team.packs),
+          inForce: layered.rules.length,
+          waivable: layered.rules.filter((x) => x.waivable).length,
+          refused: layered.refused,
+          problems: [...org.problems, ...team.problems, ...layered.problems]
+        },
+        waivers: waivers.filter((w, i, a) => a.findIndex((x) => x.change === w.change && x.rule === w.rule && x.gate === w.gate) === i),
+        overrides: stats ?? { changes: 0, rules: [], suggestions: [] }
+      }
+    };
+  }).add("GET", "/api/evals", async () => {
+    const op = await pack();
+    const stats = await overrideStats(root);
+    const t = { total: 0, applied: 0, dismissed: 0, waived: 0, asked: 0, open: 0 };
+    for (const x of stats.rules) {
+      t.total += x.total;
+      t.applied += x.applied;
+      t.dismissed += x.dismissed;
+      t.waived += x.waived;
+      t.asked += x.asked;
+      t.open += x.open;
+    }
+    return {
+      status: 200,
+      body: {
+        quality: await readQuality(root) ?? null,
+        runs: (await listReports(root)).map((x) => ({
+          runId: x.runId,
+          mode: x.mode,
+          startedAt: x.startedAt,
+          finishedAt: x.finishedAt,
+          runs: x.runs,
+          agents: x.agents,
+          failed: x.results.filter((c) => !c.pass).length,
+          skipped: x.skipped.length,
+          ...x.liveBar ? { liveBar: x.liveBar.pass } : {}
+        })),
+        findings: t,
+        modes: op.runtime.modes,
+        models: op.runtime.models.allowed
+      }
+    };
+  }).add("POST", "/api/evals/run", async ({ body }) => {
+    const b = parseBody2(api_exports.EvalRunRequest, body);
+    if (b.mode === "live")
+      throw badRequest("Live evals call a real model, so the app doesn't start them. Run atticus eval run --mode live in a terminal.");
+    const res = await run2((io) => evalRun(root, {
+      mode: b.mode,
+      json: true,
+      ...b.agents ? { agent: b.agents } : {},
+      ...b.runs ? { runs: b.runs } : {}
+    }, io, nowDate ? { now: nowDate } : {}));
+    const out = jsonOf(res);
+    if (res.code === 2 || !out)
+      throw refused2(res.code === 2 ? res : { ...res, code: 1 });
+    ctx.events.publish({ type: "file.changed", path: ".evals/quality.json" });
+    return { status: 200, body: { ...out, problems: res.err } };
+  }).add("GET", "/api/evals/defences", async () => {
+    const res = await run2((io) => defencesScan(root, void 0, { json: true }, io));
+    const scan = jsonOf(res) ?? {
+      files: [],
+      scanned: 0,
+      skipped: 0
+    };
+    const items = [];
+    for (const c of await openChanges2(root)) {
+      const dir = join3(changeFolder(root, c.id), "review", "defences");
+      for (const f of (await readdir2(dir).catch(() => [])).sort()) {
+        if (!f.endsWith(".json"))
+          continue;
+        try {
+          const list = JSON.parse(await readFile2(join3(dir, f), "utf8"));
+          for (const q of list)
+            items.push({
+              change: c.id,
+              file: `review/defences/${f}`,
+              source: q.source,
+              origin: q.origin,
+              summary: q.summary,
+              fix: q.fix,
+              question: q.question,
+              signals: q.signals.length
+            });
+        } catch {
+        }
+      }
+    }
+    return { status: 200, body: { ...scan, items, problems: res.err } };
+  }).add("GET", "/api/learning", async () => {
+    const { lessons, problems } = await lessonsFor(root);
+    const sandbox = await isSandbox(root);
+    const progress = sandbox ? await readProgress(root) : void 0;
+    const view2 = lessons.map((l) => {
+      const p = progress?.lessons[l.id];
+      const done = p ? l.steps.filter((s) => p.steps[s.id]).length : 0;
+      return {
+        id: l.id,
+        role: l.role,
+        title: l.title,
+        summary: l.summary,
+        minutes: l.minutes,
+        steps: l.steps.length,
+        done,
+        state: !p ? "not-started" : p.completedAt ? "done" : "in-progress"
+      };
+    });
+    const roles = [...new Set(lessons.map((l) => l.role))].map((role) => ({
+      role,
+      lessons: view2.filter((v) => v.role === role).length,
+      done: view2.filter((v) => v.role === role && v.state === "done").length
+    }));
+    const cur = progress?.current ? lessons.find((l) => l.id === progress.current) : void 0;
+    const lp = cur ? progress.lessons[cur.id] : void 0;
+    const next = cur?.steps.find((s) => !lp?.steps[s.id]);
+    return {
+      status: 200,
+      body: {
+        sandbox,
+        roles,
+        lessons: view2,
+        ...cur ? {
+          current: {
+            lesson: cur.id,
+            title: cur.title,
+            intro: cur.intro,
+            steps: cur.steps.length,
+            completed: !next,
+            ...next ? { step: stepOfLesson(cur, next.id) } : { outro: cur.outro }
+          }
+        } : {},
+        problems
+      }
+    };
+  }).add("POST", "/api/learning/start", async ({ body }) => {
+    const b = parseBody2(api_exports.StartLessonRequest, body);
+    const res = await run2((io) => learnStart(root, b.lesson, { json: true }, io, nowDate ? { now: nowDate() } : {}));
+    const out = jsonOf(res);
+    if (res.code !== 0 || !out)
+      throw refused2(res);
+    return { status: 200, body: out };
+  }).add("POST", "/api/learning/check", async ({ body }) => {
+    const b = parseBody2(api_exports.CheckLessonRequest, body);
+    const res = await run2((io) => learnCheck(root, {
+      json: true,
+      ...b.answer !== void 0 && b.answer !== "" ? { answer: b.answer } : {},
+      ...b.lesson ? { lesson: b.lesson } : {},
+      ...b.step ? { step: b.step } : {}
+    }, io, nowDate ? { now: nowDate() } : {}));
+    const out = jsonOf(res);
+    if (!out)
+      throw refused2(res.code === 0 ? { ...res, code: 1 } : res);
+    let hint;
+    if (!out.pass) {
+      const l = (await lessonsFor(root)).lessons.find((x) => x.id === out.lesson);
+      hint = l?.steps.find((s) => s.id === out.step)?.hint;
+    }
+    return { status: 200, body: { ...out, ...hint ? { hint } : {} } };
+  }).add("POST", "/api/learning/sandbox", async ({ body }) => {
+    const b = parseBody2(api_exports.SandboxRequest, body);
+    const res = await run2((io) => sandboxCreate(resolve(b.dir), { json: true }, io, nowDate ? { now: nowDate() } : {}));
+    const out = jsonOf(res);
+    if (res.code !== 0 || !out)
+      throw refused2(res);
+    return { status: 201, body: out };
+  }).add("GET", "/api/settings", async () => {
+    const op = await pack();
+    const rt = op.runtime;
+    const ex = await executorsOf(root, deps);
+    const names = new Set(ex.executors.map((e) => e.name));
+    const kinds = [
+      "workTracker",
+      "serviceDesk",
+      "gitHost",
+      "wiki",
+      "notify",
+      "design",
+      "model"
+    ];
+    return {
+      status: 200,
+      body: {
+        runtime: {
+          assistants: rt.assistants,
+          editors: rt.editors,
+          modes: rt.modes,
+          models: rt.models,
+          autonomy: rt.autonomy,
+          budgets: rt.budgets,
+          retention: rt.retention,
+          telemetry: rt.telemetry,
+          buildEngine: rt.buildEngine ?? { default: "speckit", perRepo: {} }
+        },
+        adapters: kinds.map((kind) => {
+          const cfg = rt.adapters[kind];
+          return {
+            kind,
+            type: cfg?.type ?? null,
+            mode: !cfg ? "not-set" : cfg.type === "manual" ? "manual" : cfg.type === "mock" ? "mock" : "live"
+          };
+        }),
+        executors: {
+          configured: ex.executors.map((e) => ({
+            name: e.name,
+            transport: e.transport,
+            where: e.transport === "http" ? e.url : [e.command, ...e.args].join(" "),
+            fillOnly: e.fillOnly,
+            covers: [...e.procedures, ...e.stepKinds],
+            allowedFor: op.procedures.filter((p) => p.executors.allowed.includes(e.name)).map((p) => p.id)
+          })),
+          missing: op.procedures.flatMap((p) => p.executors.allowed.filter((n) => !names.has(n)).map((n) => ({ procedure: p.id, executor: n }))),
+          problems: ex.problems
+        },
+        orgPack: {
+          platforms: op.profiles.map((p) => p.platform),
+          ...op.pack ? { pack: op.pack } : {},
+          counts: {
+            patterns: op.patterns.length,
+            dialects: op.dialects.length,
+            checklists: op.checklists.length,
+            agents: op.agents.length,
+            procedures: op.procedures.length,
+            serviceRequests: op.serviceRequests.length,
+            profiles: op.profiles.length,
+            skills: op.skills.length
+          },
+          defaulted: op.defaulted,
+          problems: op.problems
+        },
+        gates: op.gates.gates.map((g) => ({
+          id: g.id,
+          phase: g.phase,
+          checklists: g.checklists,
+          checks: g.checks.map((c) => c.check),
+          // ADR 0087: null when the gate has no round limit.
+          maxAuthorRounds: gateRoundLimit(op.gates, g.id) ?? null
+        }))
+      }
+    };
+  }).add("GET", "/api/settings/executors/check", async () => {
+    const res = await run2((io) => executorsCheck(root, { json: true }, io, deps.todo ?? {}));
+    const out = jsonOf(res);
+    if (!out)
+      throw refused2({ ...res, code: 1 });
+    return { status: 200, body: out };
+  });
+}
+
+// packages/cli/dist/ui-api-me.js
+async function meView(ctx) {
+  const op = await loadOrgPack(orgPackDirOf(ctx.root));
+  const me = await readMe(ctx.root);
+  const p = ctx.person;
+  return {
+    user: ctx.user,
+    ...p?.name ? { name: p.name } : {},
+    ...p?.email ? { email: p.email } : {},
+    source: p?.source ?? "given",
+    ...p?.warning ? { warning: p.warning } : {},
+    ai: op.runtime.ai,
+    notify: {
+      digest: me.notify?.digest ?? "off",
+      ...me.notify?.channel ? { channel: me.notify.channel } : {}
+    },
+    // WP7.5: the changes the person follows.
+    watching: me.watch
+  };
+}
+function uiMeRoutes(r, ctx, deps = {}) {
+  return r.add("GET", "/api/me", async () => ({ status: 200, body: await meView(ctx) })).add("PUT", "/api/me/notify", async ({ body }) => {
+    const b = api_exports.SaveNotifyRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say how often: { digest: off | daily | weekly, channel?: <channel> }.");
+    const me = await readMe(ctx.root);
+    await writeMe(ctx.root, {
+      ...me,
+      notify: { digest: b.data.digest, ...b.data.channel ? { channel: b.data.channel } : {} }
+    });
+    return { status: 200, body: await meView(ctx) };
+  }).add("PUT", "/api/me/watch", async ({ body }) => {
+    const b = api_exports.WatchRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which change and whether: { change, watch: true }.");
+    const me = await readMe(ctx.root);
+    const watch = b.data.watch ? [...me.watch, b.data.change] : me.watch.filter((c) => c !== b.data.change);
+    await writeMe(ctx.root, { ...me, watch });
+    return { status: 200, body: await meView(ctx) };
+  }).add("POST", "/api/me/digest", async ({ body }) => {
+    const b = api_exports.SendDigestRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Send { send: true } to post it, or {} to see it.");
+    const me = await readMe(ctx.root);
+    const out = [];
+    const err = [];
+    const code = await digestCommand(ctx.root, {
+      as: ctx.user,
+      ...me.notify?.channel ? { channel: me.notify.channel } : {},
+      send: b.data.send,
+      json: true
+    }, { out: (l) => out.push(l), err: (l) => err.push(l) }, deps);
+    if (code === 2)
+      throw new HttpError(400, "The request isn't valid", err.join("\n"));
+    return { status: 200, body: JSON.parse(out.join("\n")) };
+  });
+}
+
+// packages/cli/dist/ui-api-know.js
+var ID = /^[a-z0-9][a-z0-9._-]*$/;
+var VIEWS = {
+  coverage: () => ["coverage"],
+  questions: () => ["questions"],
+  intake: () => ["intake", "list"],
+  triage: () => ["triage"],
+  features: (id) => id ? ["feature", "show", id] : ["feature", "list"],
+  glossary: () => ["glossary", "list"],
+  "critic-stats": () => ["critic", "stats"],
+  conflicts: () => ["change", "conflicts"],
+  findings: (id) => id ? ["findings", id] : void 0,
+  drift: (id) => id ? ["drift", id] : void 0,
+  trace: (id) => id ? ["trace", id, "--no-write"] : void 0,
+  "story-bar": (id) => id ? ["plan", "bar", id] : void 0,
+  sources: () => ["sources", "sync"],
+  initiatives: (id) => id ? ["initiative", "status", id] : void 0,
+  reconcile: () => ["reconcile"]
+};
+var DIAGRAM_VIEWS = ["context", "container", "data", "event", "sequence"];
+var scanFirst = (words) => /catalog is empty|scan first/i.test(words);
+function uiKnowRoutes(r, ctx, o = {}) {
+  const doctor = o.doctor ?? ((root) => doctorChecks(root, { portFree: async () => true }));
+  let checked;
+  const machine = (fresh = false) => {
+    if (fresh || !checked || Date.now() - checked.at > 3e5) {
+      const run3 = { at: Date.now(), checks: doctor(ctx.root) };
+      checked = run3;
+      run3.checks.catch(() => {
+        if (checked === run3)
+          checked = void 0;
+      });
+    }
+    return checked.checks;
+  };
+  if (o.warm)
+    void machine().catch(() => void 0);
+  const view2 = async (name, arg) => {
+    const build = VIEWS[name];
+    if (!build)
+      throw notFound(`There is no view ${name}.`);
+    if (arg !== void 0 && !ID.test(arg))
+      throw badRequest(`${arg} isn't an id.`);
+    const args = build(arg);
+    if (!args)
+      throw badRequest(`The ${name} view needs an id: /api/view/${name}/<id>.`);
+    const { main } = await import("./chunk-MTAUZW2Z.js");
+    const out = [];
+    const err = [];
+    const code = await main([...args, "--json", "--root", ctx.root], { out: (l) => out.push(l), err: (l) => err.push(l) }, { quiet: true });
+    const text2 = out.join("\n").trim();
+    if (code === 2) {
+      const words = err.join("\n") || "The command refused the request.";
+      if (scanFirst(words))
+        throw new HttpError(422, "Atticus can't show that yet", words, { notYet: true });
+      throw badRequest(words);
+    }
+    let body;
+    try {
+      body = text2 ? JSON.parse(text2) : null;
+    } catch {
+      body = void 0;
+    }
+    if (body === void 0) {
+      const words = [...err, ...out].join("\n") || "No output.";
+      throw new HttpError(422, "Atticus can't show that yet", words, scanFirst(words) ? { notYet: true } : void 0);
+    }
+    return { status: 200, body: { code, data: body, problems: err } };
+  };
+  const text = async (args) => {
+    const { main } = await import("./chunk-MTAUZW2Z.js");
+    const out = [];
+    const err = [];
+    const code = await main([...args, "--root", ctx.root], { out: (l) => out.push(l), err: (l) => err.push(l) }, { quiet: true });
+    if (code === 2) {
+      const words = err.join("\n") || "The command refused the request.";
+      if (scanFirst(words))
+        throw new HttpError(422, "Atticus can't show that yet", words, { notYet: true });
+      throw badRequest(words);
+    }
+    return { code, text: out.join("\n"), problems: err };
+  };
+  return r.add("POST", "/api/triage/{itemId}/decide", async ({ params, body }) => {
+    const b = api_exports.TriageDecideRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Some fields aren't right.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const { triageDecide } = await import("./chunk-NNUASOAA.js");
+    const out = [];
+    const err = [];
+    const code = await triageDecide(ctx.root, params.itemId, b.data.option, { by: ctx.user, ...b.data.reason ? { reason: b.data.reason } : {} }, { out: (l) => out.push(l), err: (l) => err.push(l) });
+    if (code !== 0) {
+      const detail = [...err, ...out].join("\n") || "Atticus refused.";
+      if (/There is no open triage item/.test(detail))
+        throw notFound(detail);
+      throw code === 2 ? badRequest(detail) : new HttpError(422, "Atticus refused", detail);
+    }
+    ctx.events.publish({ type: "file.changed", path: "catalog/curated" });
+    return { status: 200, body: { item: params.itemId, option: b.data.option, lines: out } };
+  }).add("GET", "/api/setup", async () => ({
+    status: 200,
+    body: await setupSteps(ctx.root, { doctor: machine() })
+  })).add("GET", "/api/doctor", async ({ query }) => {
+    const checks = await machine(query.get("fresh") === "1");
+    return { status: 200, body: { checks, ok: !checks.some((c) => c.status === "fail") } };
+  }).add("POST", "/api/baseline", async ({ body }) => {
+    const b = api_exports.BaselineRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Some fields aren't right.");
+    const out = [];
+    const err = [];
+    const code = await baselineCommand(ctx.root, { by: ctx.user, ...b.data.note ? { note: b.data.note } : {} }, { out: (l) => out.push(l), err: (l) => err.push(l) });
+    if (code !== 0)
+      throw new HttpError(422, "Atticus refused", [...err, ...out].join("\n"));
+    ctx.events.publish({ type: "file.changed", path: "catalog/baseline.yaml" });
+    return {
+      status: 200,
+      body: { lines: out, ...await setupSteps(ctx.root, { doctor: await machine() }) }
+    };
+  }).add("GET", "/api/guide/{system}", async ({ params }) => {
+    const id = params.system;
+    if (!ID.test(id))
+      throw badRequest(`${id} isn't an id.`);
+    try {
+      return {
+        status: 200,
+        body: systemGuide(await catalogRecords(ctx.root), id, {
+          changes: await openChanges(ctx.root)
+        })
+      };
+    } catch (e) {
+      throw notFound(e.message);
+    }
+  }).add("GET", "/api/initiatives", async () => {
+    const v = await readView(ctx.root);
+    const body = [];
+    for (const i of v.all("Initiative").sort((a, b) => a.id.localeCompare(b.id)))
+      body.push(await initiativeStatus(ctx.root, i.id));
+    return { status: 200, body };
+  }).add("GET", "/api/diagram/{view}", async ({ params, query }) => {
+    const name = params.view;
+    if (!DIAGRAM_VIEWS.includes(name))
+      throw badRequest(`${name} isn't a view. Views: ${DIAGRAM_VIEWS.join(", ")}.`);
+    const focus = query.get("focus") ?? void 0;
+    if (focus !== void 0 && !ID.test(focus))
+      throw badRequest(`${focus} isn't an id.`);
+    return {
+      status: 200,
+      body: await text(["diagram", "render", name, ...focus ? ["--focus", focus] : []])
+    };
+  }).add("GET", "/api/diagram/{view}/graph", async ({ params, query }) => {
+    const name = params.view;
+    if (!DIAGRAM_VIEWS.includes(name) || name === "sequence")
+      throw badRequest(`${name} has no canvas. Views: ${DIAGRAM_VIEWS.filter((v) => v !== "sequence").join(", ")}.`);
+    const focus = query.get("focus") ?? void 0;
+    if (focus !== void 0 && !ID.test(focus))
+      throw badRequest(`${focus} isn't an id.`);
+    const r2 = await text([
+      "diagram",
+      "render",
+      name,
+      "--format",
+      "json",
+      ...focus ? ["--focus", focus] : []
+    ]);
+    const out = r2.text.trim();
+    if (!out.startsWith("{")) {
+      const words = r2.problems.join("\n") || "Nothing to draw.";
+      throw new HttpError(422, "Atticus can't show that yet", words, scanFirst(words) ? { notYet: true } : void 0);
+    }
+    return { status: 200, body: { view: JSON.parse(out) } };
+  }).add("GET", "/api/view/{name}", ({ params }) => view2(params.name)).add("GET", "/api/view/{name}/{id}", ({ params }) => view2(params.name, params.id));
+}
+
+// packages/cli/dist/ui-api-questions.js
+function uiQuestionRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return r.add("GET", "/api/questions", async ({ query }) => {
+    const state = strParam(query, "state");
+    if (state !== void 0 && !QuestionState.safeParse(state).success)
+      throw badRequest("state is open, answered or retired.");
+    const mine = strParam(query, "mine");
+    if (mine !== void 0 && mine !== "true")
+      throw badRequest("mine is true, or left out.");
+    const listed = await listQuestions(ctx.root, state ? { state } : {});
+    const { routeQuestions } = await import("./chunk-QICFHVRW.js");
+    const routed = await routeQuestions(ctx.root, listed.questions, mine ? { mine: ctx.user } : {});
+    const body = {
+      questions: routed.questions,
+      problems: [...listed.problems, ...routed.problems],
+      about: routed.about,
+      ...routed.me ? { me: routed.me } : {}
+    };
+    return { status: 200, body };
+  }).add("GET", "/api/questions/{id}", async ({ params }) => {
+    const q = await readQuestion(ctx.root, params.id).catch(() => {
+      throw new HttpError(422, "Atticus can't read that question", `questions/${params.id}.yaml isn't a valid question.`);
+    });
+    if (!q)
+      throw notFound(`There is no question ${params.id}.`);
+    return { status: 200, body: q };
+  }).add("GET", "/api/questions/{id}/evidence", async ({ params }) => {
+    const q = await readQuestion(ctx.root, params.id).catch(() => void 0);
+    if (!q)
+      throw notFound(`There is no question ${params.id}.`);
+    const { evidenceExcerpts } = await import("./chunk-R6B6XAKK.js");
+    return {
+      status: 200,
+      body: {
+        excerpts: await evidenceExcerpts(ctx.root, { repo: q.repo, evidence: q.evidence })
+      }
+    };
+  }).add("POST", "/api/questions/{id}/answer", async ({ params, body }) => {
+    const b = api_exports.AnswerQuestionRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest('Answer with { option: <n> } or { text: "your own words" }.', {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    try {
+      const { acceptProposal: acceptProposal2, ...given } = b.data;
+      const r2 = acceptProposal2 ? await acceptProposal(ctx.root, params.id, {
+        ...given.scope ? { scope: given.scope } : {},
+        ...given.repoType ? { repoType: given.repoType } : {},
+        ...given.match ? { match: given.match } : {},
+        by: ctx.user,
+        at: now().toISOString()
+      }) : await answerQuestion(ctx.root, params.id, {
+        ...given,
+        by: ctx.user,
+        at: now().toISOString()
+      });
+      return {
+        status: 200,
+        body: {
+          question: r2.question,
+          rerun: r2.question.rerun,
+          ...r2.skill ? { skill: r2.skill } : {}
+        }
+      };
+    } catch (e) {
+      if (!(e instanceof QuestionError))
+        throw e;
+      if (e.code === "not-found")
+        throw notFound(e.message);
+      if (e.code === "bad-answer")
+        throw badRequest(e.message);
+      throw new HttpError(422, "Atticus can't do that yet", e.message);
+    }
+  });
+}
+
+// packages/cli/dist/ui-api-across.js
+var ACROSS_VIEWS = [
+  "findings",
+  "tasks",
+  "stories",
+  "tests",
+  "requests",
+  "releases"
+];
+async function openChanges3(root) {
+  return (await changeStore(root).list()).filter((c) => c.state !== "archived").sort((a, b) => a.id.localeCompare(b.id));
+}
+async function latestFindings3(root, change) {
+  const out = [];
+  for (const gate of await reviewedGates(root, change)) {
+    const rounds = await roundsOf(root, change, gate);
+    if (rounds.length)
+      out.push(...(await readRound(root, change, gate, rounds.at(-1))).findings.map((f) => f.finding));
+  }
+  return out;
+}
+var SEVERITY_ORDER = ["blocking", "gap", "risk", "idea"];
+var AT_RELEASE = /* @__PURE__ */ new Set(["release-ready", "released", "post-release-review"]);
+async function acrossRows(root, view2) {
+  const changes = await openChanges3(root);
+  const rows = [];
+  const op = view2 === "requests" ? await loadOrgPack(orgPackDirOf(root)) : void 0;
+  const steps = view2 === "requests" ? await fileStepStore(root).list({ system: "service-desk" }).catch(() => []) : [];
+  for (const c of changes) {
+    const base = { change: c.id, changeTitle: c.title, changeState: c.state };
+    const dir = changeFolder(root, c.id);
+    switch (view2) {
+      case "findings":
+        for (const f of await latestFindings3(root, c.id))
+          rows.push({
+            ...base,
+            id: f.id,
+            gate: f.gate,
+            lens: f.lens,
+            severity: f.severity,
+            state: f.state,
+            summary: f.summary,
+            artifact: f.artifact
+          });
+        break;
+      case "tasks":
+        for (const t of readChangeTasks(await readChangeFiles(dir)))
+          rows.push({
+            ...base,
+            id: t.id,
+            repo: t.repo,
+            description: t.title,
+            done: t.done,
+            ...t.stories[0] ? { story: t.stories[0] } : {}
+          });
+        break;
+      case "stories": {
+        const files = await readChangeFiles(dir);
+        for (const s of readStoryIndex(files)) {
+          const story = readStory(files, s.id);
+          rows.push({
+            ...base,
+            id: s.id,
+            title: s.title,
+            repos: s.repos,
+            dependsOn: s.dependsOn,
+            written: !!story,
+            criteria: story?.criteria.length ?? 0
+          });
+        }
+        break;
+      }
+      case "tests": {
+        const m = await traceMatrix(root, c.id).catch(() => void 0);
+        if (!m)
+          break;
+        const reqRows = m.rows.filter((r) => r.requirement);
+        rows.push({
+          ...base,
+          requirements: m.requirements.length,
+          tested: reqRows.filter((r) => r.tests.length > 0).length,
+          rows: reqRows.length,
+          stories: m.stories.length,
+          gaps: m.gaps.length,
+          topGaps: m.gaps.slice(0, 3).map((g) => g.summary)
+        });
+        break;
+      }
+      case "requests":
+        for (const r of await readServiceRequests(dir, await readChangeFiles(dir), op.serviceRequests, steps.filter((s) => s.change === c.id), []))
+          rows.push({
+            ...base,
+            heading: r.heading,
+            requestType: r.requestType,
+            record: r.record,
+            state: r.state,
+            missing: r.missing,
+            ...r.leadTimeDays !== void 0 ? { leadTimeDays: r.leadTimeDays } : {},
+            ...r.number ? { number: r.number } : {}
+          });
+        break;
+      case "releases": {
+        const rep = await changeReport(root, c.id);
+        const h = liveHandoff(c);
+        rows.push({
+          ...base,
+          atRelease: AT_RELEASE.has(c.state),
+          ...rep.phase ? { phase: rep.phase } : {},
+          ...rep.next ? { next: rep.next } : {},
+          nextStep: rep.nextStep,
+          risk: rep.risk.level,
+          blockers: rep.blockers.length,
+          ...h ? { handoff: { phase: h.phase, pr: h.pr.url, state: h.state } } : {}
+        });
+        break;
+      }
+    }
+  }
+  if (view2 === "findings")
+    rows.sort((a, b) => Number(a.state !== "open") - Number(b.state !== "open") || SEVERITY_ORDER.indexOf(String(a.severity)) - SEVERITY_ORDER.indexOf(String(b.severity)) || a.change.localeCompare(b.change));
+  if (view2 === "releases")
+    rows.sort((a, b) => Number(b.atRelease) - Number(a.atRelease));
+  return rows;
+}
+var pathKey = (s) => s.toLowerCase().replace(/\{[^}]*\}|:[a-z0-9_]+/g, "{}").replace(/\/+$/, "").trim();
+function hopKey(heading) {
+  const m = /^\s*(get|post|put|patch|delete|head|options)\s+(\S+)/i.exec(heading);
+  return m ? { method: m[1].toUpperCase(), path: pathKey(m[2]) } : { path: pathKey(heading) };
+}
+async function mappingGrid(root, change, records) {
+  const files = await readChangeFiles(changeFolder(root, change));
+  const doc = files.docs.get("mappings.md");
+  const all = records ?? await catalogRecords(root);
+  const mappings = all.filter((r) => r.kind === "FieldMapping");
+  const interfaces = all.filter((r) => r.kind === "Interface");
+  const hops = [];
+  for (const s of doc?.sections.filter((x) => x.level === 2) ?? []) {
+    const body = doc.lines.slice(s.line, s.end).join("\n");
+    const table = doc.tables.find((t) => t.line > s.line && t.line <= s.end);
+    const cell = (r, ...names) => names.map((n) => r[n]).find((v) => v !== void 0) ?? "";
+    const rows = (table?.rows ?? []).map((r) => ({
+      line: r.line,
+      source: cell(r.cells, "source field", "source"),
+      target: cell(r.cells, "target field", "target"),
+      rule: cell(r.cells, "rule or transformation", "transform", "rule"),
+      whenMissing: cell(r.cells, "when missing or invalid", "when missing")
+    }));
+    const k = hopKey(s.heading);
+    const ifIds = new Set(interfaces.filter((i) => pathKey(i.normalizedPath) === k.path && (!k.method || !i.method || i.method.toUpperCase() === k.method)).map((i) => i.id));
+    const noChange = /no mapping change/i.test(body);
+    const note = noChange ? body.replace(/\s+/g, " ").replace(/^.*?no mapping change\.?\s*/i, "").trim() : void 0;
+    hops.push({
+      heading: s.heading,
+      line: s.line,
+      noChange,
+      ...note ? { note } : {},
+      rows,
+      asIs: asIsFor(mappings, ifIds),
+      from: "mappings.md"
+    });
+  }
+  if (!hops.length)
+    hops.push(...await hopsFromTargetFlows(changeFolder(root, change), mappings, interfaces));
+  return { change, hops, catalogMappings: mappings.length };
+}
+var asIsFor = (mappings, ifIds) => mappings.filter((m) => ifIds.has(m.interface)).map((m) => ({
+  id: m.id,
+  interface: m.interface,
+  source: m.sourceField,
+  target: m.targetField,
+  ...m.transform ? { transform: m.transform } : {}
+}));
+async function hopsFromTargetFlows(dir, mappings, interfaces) {
+  const { deltas } = await readDeltas(dir);
+  const hops = [];
+  for (const d of deltas) {
+    let at = 0;
+    for (const s of d.steps) {
+      at += 1;
+      const heading = s.to ? s.to.entry : s.store ? s.store.table : void 0;
+      if (!heading)
+        continue;
+      const as = s.fields?.as ?? {};
+      const derived = s.fields?.derived ?? {};
+      const names = fieldNames(s.fields);
+      if (!names.length)
+        continue;
+      const k = hopKey(heading);
+      const ifIds = new Set(interfaces.filter((i) => pathKey(i.normalizedPath) === k.path && (!k.method || !i.method || i.method.toUpperCase() === k.method)).map((i) => i.id));
+      hops.push({
+        heading,
+        line: at,
+        noChange: false,
+        rows: names.map((name, i) => ({
+          line: i + 1,
+          source: name,
+          target: as[name] ?? name,
+          rule: derived[name] ?? "",
+          whenMissing: ""
+        })),
+        asIs: asIsFor(mappings, ifIds),
+        from: `target-flows/${d.flow}.yaml`
+      });
+    }
+  }
+  return hops;
+}
+function uiAcrossRoutes(r, ctx) {
+  const { root } = ctx;
+  return r.add("GET", "/api/across", async ({ query }) => {
+    const view2 = strParam(query, "view") ?? "";
+    if (!ACROSS_VIEWS.includes(view2))
+      throw badRequest(`Say which view: ?view= one of ${ACROSS_VIEWS.join(", ")}.`);
+    const rows = await acrossRows(root, view2);
+    return {
+      status: 200,
+      body: { view: view2, changes: (await openChanges3(root)).length, rows }
+    };
+  }).add("GET", "/api/changes/{changeId}/mappings", async ({ params }) => {
+    try {
+      await changeStore(root).read(params.changeId);
+    } catch {
+      throw notFound(`There is no change ${params.changeId}.`);
+    }
+    return { status: 200, body: await mappingGrid(root, params.changeId) };
+  });
+}
+
+// packages/cli/dist/ui-api-graph.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var lensOf = (v, fallback) => {
+  if (v === null)
+    return fallback;
+  const l = api_exports.GraphLens.safeParse(v);
+  if (!l.success)
+    throw badRequest(`${v} isn't a lens. Lenses: ${api_exports.GRAPH_LENSES.join(", ")}.`);
+  return l.data;
+};
+var idOf = (id) => {
+  if (!api_exports.HierId.safeParse(id).success)
+    throw badRequest(`${id} isn't a node id. Use estate, or <kind>:<record id>, e.g. system:ledger.`);
+  return id;
+};
+var keyOf = (k) => {
+  if (!ViewKey.safeParse(k).success)
+    throw badRequest(`${k} isn't a view key. Use <lens>.<node>, e.g. architecture.estate.`);
+  return k;
+};
+function uiGraphRoutes(r, ctx) {
+  const estate = async () => {
+    const records = await catalogRecords(ctx.root);
+    if (!records.length)
+      throw new HttpError(422, "Atticus can't show that yet", "The catalog is empty: read the repos first (atticus map <repo>, then atticus verify <repo> --write).", { notYet: true });
+    return buildEstate(records);
+  };
+  const guard = (f) => {
+    try {
+      return f();
+    } catch (e) {
+      if (e instanceof NoSuchNode)
+        throw notFound(e.message);
+      throw e;
+    }
+  };
+  const readLayout = async (view2) => {
+    try {
+      const f = DiagramLayout.safeParse((0, import_yaml2.parse)(await readFile3(join4(ctx.root, layoutPath(view2)), "utf8")));
+      if (!f.success)
+        throw new HttpError(422, "Atticus refused", `${layoutPath(view2)} isn't a layout file.`);
+      return f.data;
+    } catch (e) {
+      if (e.code === "ENOENT")
+        return void 0;
+      throw e;
+    }
+  };
+  return r.add("GET", "/api/graph/node/{id}", async ({ params, query }) => {
+    const id = idOf(params.id);
+    const lens = lensOf(query.get("lens"), "architecture");
+    const d = query.get("depth");
+    if (d !== null && !/^[1-3]$/.test(d))
+      throw badRequest("depth is 1, 2 or 3.");
+    const est = await estate();
+    return {
+      status: 200,
+      body: guard(() => nodeView(est, id, { lens, depth: d ? Number(d) : 1, all: query.get("all") === "1" }))
+    };
+  }).add("GET", "/api/graph/focus/{id}", async ({ params, query }) => {
+    const id = idOf(params.id);
+    const lens = lensOf(query.get("lens"), "data");
+    const est = await estate();
+    return { status: 200, body: guard(() => focusView(est, id, { lens })) };
+  }).add("GET", "/api/graph/layout/{viewKey}", async ({ params }) => {
+    const view2 = keyOf(params.viewKey);
+    const f = await readLayout(view2);
+    return {
+      status: 200,
+      body: { view: view2, saved: !!f, path: layoutPath(view2), positions: f?.positions ?? {} }
+    };
+  }).add("PUT", "/api/graph/layout/{viewKey}", async ({ params, body }) => {
+    const view2 = keyOf(params.viewKey);
+    const b = api_exports.PutLayoutRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Some fields aren't right.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const { lens, node, positions } = b.data;
+    if (view2 !== viewKey(lens, node) && view2 !== viewKey(lens, node, "focus"))
+      throw badRequest(`${view2} isn't the view key of ${node} in the ${lens} lens.`);
+    if (Object.keys(positions).length > 5e3)
+      throw badRequest("At most 5000 boxes per view.");
+    const sorted = Object.fromEntries(Object.entries(positions).sort(([a], [b2]) => a < b2 ? -1 : 1).map(([k, p]) => [k, { x: Math.round(p.x), y: Math.round(p.y) }]));
+    const file = DiagramLayout.parse({
+      schemaVersion: LAYOUT_SCHEMA_VERSION,
+      view: view2,
+      lens,
+      node,
+      by: ctx.user,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      positions: sorted
+    });
+    await writeFileAtomic(join4(ctx.root, layoutPath(view2)), (0, import_yaml2.stringify)(file));
+    ctx.events.publish({ type: "file.changed", path: layoutPath(view2) });
+    return {
+      status: 200,
+      body: { view: view2, saved: true, path: layoutPath(view2), positions: file.positions }
+    };
+  });
+}
+
+// packages/cli/dist/ui-api-specs.js
+import { stat as stat2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var idOf2 = (v, what) => {
+  if (!RecordId.safeParse(v).success)
+    throw badRequest(`${v} isn't a ${what} id. Ids are lowercase: a-z, 0-9, '.', '_' and '-'.`);
+  return v;
+};
+var confirmed = (f) => f.steps.filter((s) => s.confirmedBy).length;
+function uiSpecRoutes(r, ctx) {
+  const root = ctx.root;
+  const specOf = async (repo) => {
+    if (!(await specRepos(root)).includes(repo))
+      throw notFound(`${repo} has no spec. Draft one with atticus spec draft ${repo}.`);
+    return readRepoSpec(root, repo, { cacheRoot: root });
+  };
+  const namesIn = async (repos) => {
+    const names = /* @__PURE__ */ new Map();
+    const have = new Set(await specRepos(root));
+    for (const repo of [...new Set(repos)].filter((x) => have.has(x)))
+      for (const f of (await readRepoSpec(root, repo, { cacheRoot: root })).flows)
+        names.set(f.id, f.name);
+    return names;
+  };
+  const linksOf = (joins, flow) => ({
+    out: (joins?.joins ?? []).filter((j) => j.from.flow === flow),
+    in: (joins?.joins ?? []).filter((j) => j.to.flow === flow),
+    unmatched: (joins?.unmatched ?? []).filter((u) => u.from.flow === flow)
+  });
+  r.add("GET", "/api/specs", async () => {
+    const repos = [];
+    for (const repo of await specRepos(root))
+      repos.push({
+        repo,
+        flows: (await readRepoSpec(root, repo, { cacheRoot: root })).flows.length
+      });
+    return { status: 200, body: { repos } };
+  });
+  r.add("GET", "/api/specs/{repo}", async ({ params }) => {
+    const repo = idOf2(params.repo, "repo");
+    const spec = await specOf(repo);
+    const joins = await readEstateJoins(root);
+    const body = {
+      repo,
+      path: specRelOf(root, repo),
+      ...spec.header?.commit ? { commit: spec.header.commit } : {},
+      ...spec.header?.template ? { template: spec.header.template } : {},
+      flows: spec.flows.map((f) => {
+        const l = linksOf(joins, f.id);
+        return {
+          id: f.id,
+          name: f.name,
+          component: f.component,
+          trigger: { kind: f.trigger.kind, what: f.trigger.what },
+          steps: f.steps.length,
+          confirmed: confirmed(f),
+          errors: f.errors.length,
+          calls: l.out.length,
+          calledBy: l.in.length
+        };
+      }),
+      problems: spec.problems
+    };
+    return { status: 200, body };
+  });
+  r.add("GET", "/api/specs/{repo}/flows/{flowId}", async ({ params }) => {
+    const repo = idOf2(params.repo, "repo");
+    const id = idOf2(params.flowId, "flow");
+    const flow = (await specOf(repo)).flows.find((f) => f.id === id);
+    if (!flow)
+      throw notFound(`${repo}'s spec has no flow ${id}.`);
+    const joins = await readEstateJoins(root);
+    const l = linksOf(joins, id);
+    const names = await namesIn([...l.out.map((j) => j.to.repo), ...l.in.map((j) => j.from.repo)]);
+    const named = (flowId) => {
+      const n = names.get(flowId);
+      return n ? { name: n } : {};
+    };
+    const body = {
+      repo,
+      file: `${specRelOf(root, repo)}/${id}.yaml`,
+      flow,
+      joined: joins !== void 0,
+      calls: l.out.map((j) => ({
+        step: j.from.step,
+        repo: j.to.repo,
+        flow: j.to.flow,
+        ...named(j.to.flow),
+        how: j.how
+      })),
+      calledBy: l.in.map((j) => ({
+        step: j.from.step,
+        repo: j.from.repo,
+        flow: j.from.flow,
+        ...named(j.from.flow),
+        how: j.how
+      })),
+      unmatched: l.unmatched.map((u) => ({
+        step: u.from.step,
+        entry: u.entry,
+        reason: u.reason,
+        message: u.message
+      }))
+    };
+    return { status: 200, body };
+  });
+  const deltasOf = async (change) => {
+    const dir = join5(changesDirOf(root), change);
+    if (!await stat2(join5(dir, "change.yaml")).catch(() => void 0))
+      throw notFound(`There is no change ${change}.`);
+    return readDeltas(dir);
+  };
+  const todayOf = async (repo, flow) => (await specRepos(root)).includes(repo) ? (await readRepoSpec(root, repo, { cacheRoot: root })).flows.find((f) => f.id === flow) : void 0;
+  r.add("GET", "/api/changes/{changeId}/target-flows", async ({ params }) => {
+    const change = idOf2(params.changeId, "change");
+    const { deltas, problems } = await deltasOf(change);
+    const flows = [];
+    for (const d of deltas) {
+      const m = mergeDelta(d, await todayOf(d.repo, d.flow));
+      flows.push({
+        flow: d.flow,
+        repo: d.repo,
+        change: d.change,
+        name: m.name,
+        why: d.why,
+        ...m.counts
+      });
+    }
+    return { status: 200, body: { change, flows, problems } };
+  });
+  r.add("GET", "/api/changes/{changeId}/conformance", async ({ params }) => {
+    const change = idOf2(params.changeId, "change");
+    const { conformanceOf } = await import("./chunk-F7YL2RZ4.js");
+    const c = await conformanceOf(root, change);
+    if (!c)
+      throw notFound(`There is no change ${change}.`);
+    return { status: 200, body: c };
+  });
+  r.add("GET", "/api/changes/{changeId}/estimate", async ({ params }) => {
+    const change = idOf2(params.changeId, "change");
+    const e = await estimateOf(root, change);
+    if (!e)
+      throw notFound(`There is no change ${change}.`);
+    return { status: 200, body: e };
+  });
+  r.add("GET", "/api/changes/{changeId}/impact", async ({ params }) => {
+    const change = idOf2(params.changeId, "change");
+    const { changeImpactOf } = await import("./chunk-JAA53T23.js");
+    const i = await changeImpactOf(root, change);
+    if (!i)
+      throw notFound(`There is no change ${change}.`);
+    return { status: 200, body: i };
+  });
+  r.add("GET", "/api/changes/{changeId}/map", async ({ params }) => {
+    const change = idOf2(params.changeId, "change");
+    const m = await changeMapOf(root, change);
+    if (!m)
+      throw notFound(`There is no change ${change}.`);
+    return { status: 200, body: changeMapBody(change, m) };
+  });
+  r.add("GET", "/api/changes/{changeId}/target-flows/{flowId}", async ({ params }) => {
+    const change = idOf2(params.changeId, "change");
+    const flow = idOf2(params.flowId, "flow");
+    const d = (await deltasOf(change)).deltas.find((x) => x.flow === flow);
+    if (!d)
+      throw notFound(`Change ${change} has no target flow ${flow}.`);
+    const { flow: _f, repo: _r, change: delta, ...m } = mergeDelta(d, await todayOf(d.repo, flow));
+    const body = {
+      change,
+      file: `${changesRelOf(root)}/${change}/${TARGET_DIR}/${flow}.yaml`,
+      flow,
+      repo: d.repo,
+      delta,
+      ...m
+    };
+    return { status: 200, body };
+  });
+  return r;
+}
+
+// packages/cli/dist/ui-api-knowledge.js
+var import_yaml3 = __toESM(require_dist(), 1);
+import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+var STALE_DAYS = 14;
+var SLUG = /^[a-z0-9][a-z0-9-]*$/;
+var DAY = 864e5;
+var stamp = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+var idOf3 = (v, what) => {
+  if (!RecordId.safeParse(v).success)
+    throw badRequest(`${v} isn't a ${what} id. Ids are lowercase: a-z, 0-9, '.', '_' and '-'.`);
+  return v;
+};
+var invalid = (what, e) => badRequest(what, {
+  errors: e.issues.map((i) => ({ path: i.path.map(String).join("."), message: i.message }))
+});
+function asSet(set) {
+  if (!set)
+    return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(set))
+    out[k] = typeof v === "string" ? v : v.map((x) => typeof x === "string" ? x : x.label?.trim() ? `${x.label.trim()}=${x.url}` : x.url);
+  return out;
+}
+var keepAs = (recordKind) => KNOWLEDGE_KINDS.filter((k) => KNOWLEDGE_RECORD_KIND[k] === recordKind);
+function conflictView(v) {
+  const c = v.conflict;
+  return {
+    key: v.key,
+    about: c.about,
+    ...c.summary ? { summary: c.summary } : {},
+    pages: c.pages.map((p, k) => ({ source: p.source, page: p.page, says: c.says[k] ?? "" })),
+    applies: v.applies.map((p) => ({ source: p.source, page: p.page })),
+    ...v.decided ? { decided: v.decided } : {},
+    ...v.suggested ? {
+      suggested: {
+        source: v.suggested.source,
+        page: v.suggested.page,
+        signal: v.suggested.signal,
+        detail: v.suggested.detail
+      }
+    } : {},
+    ...v.question ? { question: v.question } : {}
+  };
+}
+function itemView(r, review, conflicts = []) {
+  const mine = conflicts.filter((v) => v.conflict.about.includes(r.id));
+  return {
+    id: r.id,
+    kind: knowledgeKindOf(r) ?? keepAs(r.kind)[0],
+    recordKind: r.kind,
+    title: itemTitle(r),
+    record: r,
+    ...review ? { review } : {},
+    fields: correctableFields(r),
+    conflict: !!r.flags?.some((f) => f.startsWith("conflict:")) || mine.length > 0,
+    ...mine.length ? { conflicts: mine.map(conflictView) } : {}
+  };
+}
+function candidateView(c) {
+  const r = c.record;
+  return {
+    id: r.id,
+    kind: knowledgeKindOf(r) ?? keepAs(r.kind)[0],
+    recordKind: r.kind,
+    title: itemTitle(r),
+    record: r,
+    ...c.known ? { known: c.known } : {},
+    ...c.kept ? { kept: c.kept } : {},
+    keepAs: keepAs(r.kind)
+  };
+}
+var exists = (p) => stat3(p).then(() => true, () => false);
+function capture() {
+  const lines = [];
+  const problems = [];
+  return {
+    io: { out: (l) => lines.push(l), err: (l) => problems.push(l) },
+    lines,
+    problems
+  };
+}
+function uiKnowledgeRoutes(r, ctx, deps = {}) {
+  const root = ctx.root;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const changed = (path) => ctx.events.publish({ type: "file.changed", path });
+  const appliesView = async (change) => {
+    const file = `${changesRelOf(root)}/${change}/knowledge.yaml`;
+    const present = await exists(join6(changeFolder(root, change), "knowledge.yaml"));
+    const doc = present ? await readKnowledgeApplies(root, change) : void 0;
+    if (present && !doc)
+      throw new HttpError(422, "Atticus can't read that file", `${file} isn't a valid knowledge list.`);
+    const titles = /* @__PURE__ */ new Map();
+    if (doc?.items.some((i) => !i.title) || doc?.nearMisses.some((n) => !n.title))
+      for (const r2 of await readKnowledge(root, { cacheRoot: root }).then((k) => [
+        ...k.items,
+        ...k.rejected
+      ]))
+        titles.set(r2.id, itemTitle(r2));
+    const titled = (x) => {
+      const title = x.title ?? titles.get(x.id);
+      return title ? { ...x, title } : x;
+    };
+    const used = new Set((doc?.items ?? []).filter((i) => i.status !== "excluded").map((i) => i.id));
+    const conflicts = used.size ? (await readConflicts(root, { records: await codeFactRecords(root) }).catch(() => [])).filter((v) => conflictTouches(v, used)) : [];
+    const settings = readSourceSettings(root);
+    const quoted = /* @__PURE__ */ new Map();
+    if (settings.size && doc?.items.length) {
+      for (const r2 of (await readKnowledge(root, { cacheRoot: root })).items)
+        if (r2.quote)
+          quoted.set(r2.id, { source: r2.quote.source, page: r2.quote.page });
+    }
+    const sourceOf = (id) => {
+      const q = quoted.get(id);
+      if (q)
+        return q;
+      const hash = id.indexOf("#");
+      const slash = id.indexOf("/");
+      return hash > 0 && slash > 0 && slash < hash ? { source: id.slice(0, slash), page: id.slice(slash + 1, hash) } : void 0;
+    };
+    return {
+      change,
+      file,
+      present,
+      items: (doc?.items ?? []).map((i) => {
+        const reason = plainWhy(i);
+        const at = sourceOf(i.id);
+        const w = at ? settings.get(at.source) : void 0;
+        const authority = w && (w.authority || w.byPage?.length) ? pageStanding(w, at.page, {}).authority : void 0;
+        return {
+          ...titled(i),
+          ...reason ? { reason } : {},
+          ...at && settings.has(at.source) ? { source: at.source } : {},
+          ...authority ? { authority } : {}
+        };
+      }),
+      nearMisses: (doc?.nearMisses ?? []).map(titled),
+      ...conflicts.length ? { conflicts: conflicts.map(conflictView) } : {},
+      command: `atticus change knowledge ${change}`
+    };
+  };
+  const reviewed = async (id) => {
+    const k = await readKnowledge(root, { cacheRoot: root });
+    const item = [...k.items, ...k.rejected].find((i) => i.id === id);
+    const conflicts = await readConflicts(root, {
+      conflicts: k.report?.conflicts ?? [],
+      records: await codeFactRecords(root)
+    }).catch(() => []);
+    return item ? itemView(item, k.reviews[id], conflicts) : void 0;
+  };
+  const findView = (f) => ({
+    slug: f.slug,
+    phrase: f.phrase,
+    at: f.at,
+    file: `${knowledgeRelOf(root)}/finds/${f.slug}.yaml`,
+    matches: f.matches,
+    candidates: f.candidates.map(candidateView)
+  });
+  const draftView = async () => {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const platforms = [];
+    for (const { platform } of op.profiles) {
+      const text = await readFile4(join6(proposalsDirOf(root), "orgpack", `${platform}.yaml`), "utf8").catch(() => void 0);
+      const data = text === void 0 ? void 0 : (0, import_yaml3.parse)(text);
+      const proposals = Array.isArray(data?.proposals) ? data.proposals.flatMap((p) => {
+        const x = OrgPackProposal.safeParse(p);
+        return x.success ? [x.data] : [];
+      }) : [];
+      platforms.push({
+        platform,
+        file: `${proposalsRelOf(root)}/orgpack/${platform}.yaml`,
+        present: text !== void 0,
+        ...typeof data?.at === "string" ? { at: data.at } : {},
+        proposals,
+        command: `atticus orgpack draft --platform ${platform}`
+      });
+    }
+    return { platforms };
+  };
+  return r.add("GET", "/api/knowledge/sources", async () => {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const problems = op.problems.filter((p) => p.file === "sources.yaml").map((p) => ({
+      file: `org-pack/${p.file}`,
+      message: `${p.path ? `${p.path}: ` : ""}${p.message}`
+    }));
+    const k = await readKnowledge(root, { raw: true, cacheRoot: root });
+    const scanned = new Map((k.report?.snapshots ?? []).map((s) => [s.source, s]));
+    const today = now().getTime();
+    const sources = [];
+    for (const w of op.sources.wikis) {
+      const date = (await snapshotDates(root, w.id))[0];
+      let snapshot;
+      if (date) {
+        const file = join6(knowledgeDirOf(root), "snapshots", w.id, date, SNAPSHOT_FILE);
+        const text = await readFile4(file, "utf8").catch(() => void 0);
+        const m = text === void 0 ? void 0 : SnapshotManifest.safeParse((0, import_yaml3.parse)(text));
+        if (m?.success)
+          snapshot = {
+            date,
+            takenAt: m.data.takenAt,
+            ...m.data.commit ? { commit: m.data.commit } : {},
+            pages: m.data.pages.length,
+            skipped: m.data.skipped.length,
+            ageDays: Math.max(0, Math.floor((today - Date.parse(`${date}T00:00:00Z`)) / DAY))
+          };
+        else
+          problems.push({
+            file: `${knowledgeRelOf(root)}/snapshots/${w.id}/${date}/${SNAPSHOT_FILE}`,
+            message: "not a snapshot manifest"
+          });
+      }
+      const s = scanned.get(w.id);
+      sources.push({
+        id: w.id,
+        type: w.type,
+        location: w.location,
+        ...w.ref ? { ref: w.ref } : {},
+        ...w.path ? { path: w.path } : {},
+        ...w.checkout ? { checkout: w.checkout } : {},
+        ...w.owner ? { owner: w.owner } : {},
+        tags: { kinds: w.tags?.kinds ?? [], frameworks: w.tags?.frameworks ?? [] },
+        // 2.30.0 (ADR 0132): how much its word counts and where it applies.
+        ...w.authority ? { authority: w.authority } : {},
+        ...w.appliesTo ? { appliesTo: w.appliesTo, scope: scopeWords(w.appliesTo) } : {},
+        ...w.byPage?.length ? { byPage: w.byPage.length } : {},
+        ...w.readRestricted !== void 0 ? { readRestricted: w.readRestricted } : {},
+        ...w.maxPages ? { maxPages: w.maxPages } : {},
+        ...snapshot ? { snapshot } : {},
+        ...s ? { scanned: { date: s.date, pages: s.pages } } : {},
+        stale: !snapshot || snapshot.ageDays > STALE_DAYS,
+        commands: {
+          sync: `atticus sources sync --source ${w.id}`,
+          scan: `atticus knowledge scan --source ${w.id}`,
+          slash: `/atticus-knowledge ${w.id}`
+        }
+      });
+    }
+    const body = {
+      file: "org-pack/sources.yaml",
+      types: [...api_exports.WIKI_TYPES],
+      kindSuggestions: [...SOURCE_KIND_SUGGESTIONS],
+      staleDays: STALE_DAYS,
+      sources,
+      problems
+    };
+    return { status: 200, body };
+  }).add("POST", "/api/knowledge/sources", async ({ body }) => {
+    const b = api_exports.AddSourceRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw invalid("Some fields aren't right.", b.error);
+    const { type, location, kinds, frameworks, ...o } = b.data;
+    const c = capture();
+    const code = await sourcesAdd(root, type, location, c.io, {
+      ...o.id ? { id: o.id } : {},
+      ...o.path ? { path: o.path } : {},
+      ...o.ref ? { ref: o.ref } : {},
+      ...o.submodule ? { submodule: true } : {},
+      ...kinds?.length ? { kinds } : {},
+      ...frameworks?.length ? { frameworks } : {},
+      ...o.owner ? { owner: o.owner } : {},
+      save: o.save
+    });
+    const words = [...c.problems, ...c.lines].join("\n") || "Atticus refused.";
+    if (code === 2)
+      throw badRequest(words);
+    if (code !== 0)
+      throw new HttpError(422, "Atticus refused", words);
+    if (o.save)
+      changed("org-pack/sources.yaml");
+    return { status: 200, body: { code, lines: c.lines, problems: c.problems } };
+  }).add("POST", "/api/knowledge/sources/{sourceId}/sync", async ({ params }) => {
+    const id = idOf3(params.sourceId, "source");
+    const op = await loadOrgPack(orgPackDirOf(root));
+    if (id !== INPUTS_SOURCE_ID && !op.sources.wikis.some((w) => w.id === id))
+      throw notFound(`There is no source ${id} in org-pack/sources.yaml.`);
+    const c = capture();
+    const code = await sourcesSync(root, c.io, { source: id, now: stamp(now()) });
+    if (code === 2)
+      throw new HttpError(422, "Atticus refused", c.problems.join("\n") || "Nothing to sync.");
+    changed(`${knowledgeRelOf(root)}/snapshots/${id}`);
+    return { status: 200, body: { code, lines: c.lines, problems: c.problems } };
+  }).add("GET", "/api/knowledge/scan", async () => {
+    const k = await readKnowledge(root, { cacheRoot: root });
+    const r2 = k.report;
+    const body = {
+      ...r2 ? { scannedAt: r2.scannedAt } : {},
+      snapshots: (r2?.snapshots ?? []).map((s) => ({
+        source: s.source,
+        date: s.date,
+        pages: s.pages
+      })),
+      ...r2?.changes ? { changes: r2.changes } : {},
+      checkAgain: [...k.items, ...k.rejected].filter((i) => k.reviews[i.id]?.state === "stale").sort((a, b) => a.id.localeCompare(b.id)).map((i) => ({
+        id: i.id,
+        kind: knowledgeKindOf(i) ?? keepAs(i.kind)[0],
+        title: itemTitle(i),
+        by: k.reviews[i.id].by
+      })),
+      conflicts: r2?.conflicts.length ?? 0,
+      injections: r2?.injections.length ?? 0,
+      failed: r2?.failed.length ?? 0,
+      command: "atticus knowledge scan",
+      slash: "/atticus-knowledge"
+    };
+    return { status: 200, body };
+  }).add("GET", "/api/knowledge/items", async ({ query }) => {
+    const kind = strParam(query, "kind");
+    if (kind !== void 0 && !KNOWLEDGE_KINDS.includes(kind))
+      throw badRequest(`There is no knowledge kind ${kind}. Use one of: ${KNOWLEDGE_KINDS.join(", ")}.`);
+    const tag = strParam(query, "tag");
+    const k = await readKnowledge(root, { cacheRoot: root });
+    const items = filterItems([...k.items, ...k.rejected], {
+      ...kind ? { kind } : {},
+      ...tag ? { tag } : {}
+    }).sort((a, b) => a.id.localeCompare(b.id));
+    const conflicts = await readConflicts(root, {
+      conflicts: k.report?.conflicts ?? [],
+      records: await codeFactRecords(root)
+    }).catch(() => []);
+    const body = {
+      items: items.map((i) => itemView(i, k.reviews[i.id], conflicts)),
+      problems: k.problems.map((p) => ({
+        file: `${knowledgeRelOf(root)}/${p.file.startsWith("reviews/") || p.file === "scan.yaml" ? "" : "items/"}${p.file}`,
+        message: p.message
+      }))
+    };
+    return { status: 200, body };
+  }).add("POST", "/api/knowledge/items/{itemId}/review", async ({ params, body }) => {
+    const id = idOf3(params.itemId, "knowledge item");
+    const b = api_exports.ReviewItemRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw invalid("Say verified, corrected or rejected.", b.error);
+    const raw = await readKnowledge(root, { raw: true, cacheRoot: root });
+    const item = raw.items.find((i) => i.id === id);
+    if (!item)
+      throw notFound(`There is no knowledge item ${id}.`);
+    let set = asSet(b.data.set);
+    if (b.data.verdict === "corrected") {
+      const before = (await readReviews(root)).reviews.get(id);
+      if (before?.corrections)
+        set = { ...asSet(before.corrections), ...set };
+    }
+    const res = reviewItem(item, {
+      verdict: b.data.verdict,
+      by: ctx.user,
+      at: stamp(now()),
+      ...b.data.note ? { note: b.data.note } : {},
+      ...set && Object.keys(set).length ? { set } : {}
+    });
+    if ("error" in res)
+      throw badRequest(res.error);
+    const file = await writeReview(root, res.review);
+    changed(`${knowledgeRelOf(root)}/${file}`);
+    return {
+      status: 200,
+      body: { item: await reviewed(id), file: `${knowledgeRelOf(root)}/${file}` }
+    };
+  }).add("GET", "/api/knowledge/search", async ({ query }) => {
+    const phrase = strParam(query, "q")?.trim();
+    if (!phrase)
+      throw badRequest("Say what to look for: ?q=<a term or phrase>.");
+    if (phrase.length > 200)
+      throw badRequest("Search for a term or phrase of up to 200 characters.");
+    const source = strParam(query, "source");
+    if (source !== void 0)
+      idOf3(source, "source");
+    const ids = await snapshotSources(root);
+    if (source && !ids.includes(source))
+      throw notFound(`${source} has no snapshot yet: atticus sources sync --source ${source}.`);
+    const snapshots = [];
+    for (const s of source ? [source] : ids) {
+      const snap = await readSnapshot(root, s).catch(() => void 0);
+      if (snap)
+        snapshots.push(snap);
+    }
+    const matches = searchPages(snapshots, phrase);
+    const body = {
+      phrase,
+      sources: snapshots.length,
+      matches,
+      pages: [...new Set(matches.map((m) => `${m.source}/${m.page}`))],
+      command: `atticus knowledge find ${JSON.stringify(phrase)}${source ? ` --source ${source}` : ""}`,
+      slash: `/atticus-find ${phrase}`
+    };
+    return { status: 200, body };
+  }).add("GET", "/api/knowledge/finds", async () => {
+    const finds = [];
+    for (const f of await readFinds(root)) {
+      const s = await readFind(root, f.slug);
+      if (s)
+        finds.push(findView(s));
+    }
+    return { status: 200, body: { finds } };
+  }).add("GET", "/api/knowledge/finds/{slug}", async ({ params }) => {
+    const slug = params.slug;
+    if (!SLUG.test(slug))
+      throw badRequest(`${slug} isn't a saved search.`);
+    const f = await readFind(root, slug);
+    if (!f)
+      throw notFound(`There is no saved search ${slug}.`);
+    return { status: 200, body: findView(f) };
+  }).add("POST", "/api/knowledge/finds/{slug}/keep", async ({ params, body }) => {
+    const slug = params.slug;
+    if (!SLUG.test(slug))
+      throw badRequest(`${slug} isn't a saved search.`);
+    const b = api_exports.KeepCandidateRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw invalid("Say which candidate to keep: { item }.", b.error);
+    const f = await readFind(root, slug);
+    if (!f)
+      throw notFound(`There is no saved search ${slug}.`);
+    if (!f.candidates.some((c) => c.record.id === b.data.item))
+      throw notFound(`The search ${slug} has no candidate ${b.data.item}.`);
+    const set = asSet(b.data.set);
+    const res = await keepCandidate(root, slug, b.data.item, {
+      ...b.data.as ? { as: b.data.as } : {},
+      by: ctx.user,
+      at: stamp(now()),
+      ...b.data.note ? { note: b.data.note } : {},
+      ...set && Object.keys(set).length ? { set } : {}
+    });
+    if ("error" in res)
+      throw new HttpError(422, "Atticus refused", res.error);
+    changed(`${knowledgeRelOf(root)}/items`);
+    const item = await reviewed(b.data.item) ?? itemView(res.item, void 0);
+    return { status: 200, body: { item, as: res.as } };
+  }).add("GET", "/api/changes/{changeId}/needs", async ({ params }) => {
+    const change = idOf3(params.changeId, "change");
+    if (!await exists(changeFolder(root, change)))
+      throw notFound(`There is no change ${change}.`);
+    const fileExists = await exists(join6(changeFolder(root, change), NEEDS_FILE));
+    const f = await readNeeds(root, change);
+    if (fileExists && !f)
+      throw new HttpError(422, "Atticus can't read that file", `${changesRelOf(root)}/${change}/${NEEDS_FILE} isn't a valid needs file.`);
+    const k = f ? await readKnowledge(root, { cacheRoot: root }) : void 0;
+    const view2 = (n) => ({
+      ...n,
+      ...k?.reviews[n.item] ? { review: k.reviews[n.item] } : {}
+    });
+    const body = {
+      change,
+      file: `${changesRelOf(root)}/${change}/${NEEDS_FILE}`,
+      present: !!f,
+      ...f ? { updatedAt: f.updatedAt } : {},
+      needs: (f?.needs ?? []).map(view2),
+      considered: f?.considered ?? [],
+      command: `atticus change needs ${change}`,
+      slash: `/atticus-needs ${change}`
+    };
+    return { status: 200, body };
+  }).add("POST", "/api/changes/{changeId}/needs/{itemId}", async ({ params, body }) => {
+    const change = idOf3(params.changeId, "change");
+    const item = idOf3(params.itemId, "knowledge item");
+    const b = api_exports.MarkNeedRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw invalid("Say done, not-needed or open.", b.error);
+    if (!await exists(changeFolder(root, change)))
+      throw notFound(`There is no change ${change}.`);
+    const res = await markNeed(root, change, item, {
+      status: b.data.status,
+      by: ctx.user,
+      at: stamp(now()),
+      ...b.data.note ? { note: b.data.note } : {},
+      ...b.data.for ? { for: b.data.for } : {}
+    });
+    if ("error" in res) {
+      if (/has no need /.test(res.error))
+        throw notFound(res.error);
+      if (/has no needs yet/.test(res.error))
+        throw new HttpError(422, "Atticus can't do that yet", res.error);
+      throw badRequest(res.error);
+    }
+    const file = `${changesRelOf(root)}/${change}/${NEEDS_FILE}`;
+    changed(file);
+    const k = await readKnowledge(root, { cacheRoot: root });
+    return {
+      status: 200,
+      body: {
+        need: { ...res.need, ...k.reviews[item] ? { review: k.reviews[item] } : {} },
+        file
+      }
+    };
+  }).add("GET", "/api/changes/{changeId}/knowledge", async ({ params }) => {
+    const change = idOf3(params.changeId, "change");
+    if (!await exists(changeFolder(root, change)))
+      throw notFound(`There is no change ${change}.`);
+    return { status: 200, body: await appliesView(change) };
+  }).add("POST", "/api/changes/{changeId}/knowledge/{itemId}", async ({ params, body }) => {
+    const change = idOf3(params.changeId, "change");
+    const item = params.itemId;
+    if (!item.trim() || item.length > 400 || /[\p{Cc}]/u.test(item))
+      throw badRequest(`${JSON.stringify(item)} isn't a knowledge item id.`);
+    const b = api_exports.SetChangeKnowledgeRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw invalid("Say confirmed or excluded: { status }.", b.error);
+    if (!await exists(changeFolder(root, change)))
+      throw notFound(`There is no change ${change}.`);
+    const before = await appliesView(change);
+    if (!before.present)
+      throw new HttpError(422, "Atticus can't do that yet", `${before.file} doesn't exist yet: its stages write it when they select context (${before.command}).`);
+    try {
+      await setKnowledgeStatus(root, change, item, b.data.status);
+    } catch (e) {
+      throw notFound(e.message);
+    }
+    changed(before.file);
+    const result = {
+      knowledge: await appliesView(change),
+      file: before.file,
+      commit: `git add ${before.file} && git commit -m "${change}: the knowledge that applies"`
+    };
+    return { status: 200, body: result };
+  }).add("GET", "/api/orgpack/draft", async () => ({ status: 200, body: await draftView() })).add("POST", "/api/orgpack/draft", async ({ body }) => {
+    const b = api_exports.DraftOrgPackRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw invalid("Say which platform: { platform }.", b.error);
+    try {
+      await draftOrgPack(root, {
+        ...b.data.platform ? { platform: b.data.platform } : {},
+        now: now()
+      });
+    } catch (e) {
+      throw new HttpError(422, "Atticus refused", e.message);
+    }
+    changed(`${proposalsRelOf(root)}/orgpack`);
+    return { status: 200, body: await draftView() };
+  }).add("POST", "/api/orgpack/draft/{platform}/accept", async ({ params, body }) => {
+    const platform = idOf3(params.platform, "platform");
+    const b = api_exports.AcceptOrgPackRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw invalid("Pick the systems to accept: { only: [ids] }.", b.error);
+    try {
+      const res = await acceptOrgPackDraft(root, platform, { only: b.data.only });
+      changed(res.file);
+      return { status: 200, body: res };
+    } catch (e) {
+      const words = e.message;
+      if (/There is no draft/.test(words))
+        throw notFound(words);
+      throw new HttpError(422, "Atticus refused", words);
+    }
+  });
+}
+
+// packages/cli/dist/ui-api-runs.js
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var import_yaml4 = __toESM(require_dist(), 1);
+async function serverModel(root) {
+  return (await configuredModel(root))?.type ?? null;
+}
+async function configuredModel(root) {
+  const text = await readFile5(join7(orgPackDirOf(root), "runtime.yaml"), "utf8").catch(() => void 0);
+  if (!text)
+    return null;
+  let y;
+  try {
+    y = (0, import_yaml4.parse)(text);
+  } catch {
+    return null;
+  }
+  const type = y?.adapters?.model?.type;
+  if (typeof type !== "string" || type === "mock")
+    return null;
+  const allowed = y?.modes?.allowed;
+  if (Array.isArray(allowed) && !allowed.includes("model"))
+    return null;
+  const max = y?.adapters?.model?.settings?.maxInput;
+  return typeof max === "number" && Number.isInteger(max) && max >= 1e3 ? { type, maxInput: max } : { type };
+}
+function uiModelRunRoutes(r, ctx, deps = {}) {
+  const root = ctx.root;
+  const runStep = deps.runStep ?? (async (args) => {
+    const { main } = await import("./chunk-MTAUZW2Z.js");
+    const out = [];
+    const err = [];
+    const code = await main([...args, "--root", root], { out: (l) => out.push(l), err: (l) => err.push(l) }, { quiet: true });
+    return { code, out, err };
+  });
+  return r.add("POST", "/api/runs", async ({ body }) => {
+    const args = body?.args;
+    if (!Array.isArray(args) || args.length < 2 || !args.every((a) => typeof a === "string" && a.trim() !== ""))
+      throw badRequest(`args is the step's command words and arguments, for example ["scan", "survey", "forge-ledger"].`);
+    const words = args;
+    if (!isHandoffStep(words[0], words[1]))
+      throw badRequest(`atticus ${words.slice(0, 2).join(" ")} isn't an AI step; the app starts only those.`);
+    const option = words.find((a) => a.startsWith("-"));
+    if (option)
+      throw badRequest(`${option} would be read as an option; give the step's arguments only.`);
+    const configured = await configuredModel(root);
+    const model = configured?.type;
+    if (!model)
+      throw conflict("This server's runtime.yaml configures no model, so it can't run an AI step. Run it in your assistant (its slash command), or from VS Code with Copilot.");
+    const job = ctx.jobs.start("step", async (c) => {
+      c.progress(0, 1, `Running atticus ${words.join(" ")} with ${model}`);
+      const before = new Set((await listRuns(root, { limit: 1e5 })).map((x) => x.runId));
+      const res = await runStep([
+        ...words,
+        "--mode",
+        "model",
+        ...configured?.maxInput ? ["--max-tokens", String(configured.maxInput)] : []
+      ]);
+      const made = (await listRuns(root, { limit: 1e5 })).find((x) => !before.has(x.runId));
+      c.progress(1, 1, res.code === 0 ? "Done" : "Stopped");
+      ctx.events.publish({ type: "file.changed", path: runsRelOf(root) });
+      return {
+        result: {
+          code: res.code,
+          lines: [...res.out, ...res.err],
+          ...made ? { runId: made.runId } : {}
+        },
+        errors: res.code === 0 ? [] : res.err
+      };
+    });
+    return { status: 202, body: { jobId: job.id, model } };
+  }).add("GET", "/api/runs", async ({ query }) => {
+    const change = query.get("change") ?? void 0;
+    const limitText = query.get("limit");
+    const limit = limitText === null ? 200 : Number(limitText);
+    if (!Number.isInteger(limit) || limit < 1)
+      throw badRequest("limit is a whole number of 1 or more.");
+    const runs = await listRuns(root, { ...change ? { change } : {}, limit });
+    return {
+      status: 200,
+      body: { runs, serverModel: await serverModel(root) }
+    };
+  }).add("GET", "/api/runs/{runId}/transcript", async ({ params }) => {
+    const t = await runTranscript(root, params.runId);
+    if (!t)
+      throw notFound(`There is no run ${params.runId}.`);
+    return { status: 200, body: t };
+  });
+}
+
+// packages/cli/dist/ui-api-history.js
+function uiHistoryRoutes(r, ctx) {
+  const root = ctx.root;
+  return r.add("GET", "/api/history", async ({ query }) => {
+    const limitText = query.get("limit");
+    const limit = limitText === null ? 200 : Number(limitText);
+    if (!Number.isInteger(limit) || limit < 1)
+      throw badRequest("limit is a whole number of 1 or more.");
+    const opt = (k) => {
+      const v = query.get(k)?.trim();
+      return v ? v : void 0;
+    };
+    const change = opt("change");
+    const session = opt("session");
+    const filter = opt("q");
+    const body = await listHistory(root, {
+      ...change ? { change } : {},
+      ...session ? { session } : {},
+      ...filter ? { filter } : {},
+      limit
+    });
+    return { status: 200, body };
+  }).add("GET", "/api/history/{historyId}", async ({ params }) => {
+    const e = await historyEntry(root, params.historyId);
+    if (!e)
+      throw notFound(`There is no record ${params.historyId}.`);
+    return { status: 200, body: e };
+  });
+}
+
+// packages/cli/dist/ui-api-ai.js
+var import_yaml5 = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join8, relative, sep } from "node:path";
+var unprocessable = (detail) => new HttpError(422, "The settings aren't valid", detail);
+var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+var FIELDS = ["ai", "modes", "assistants", "models", "budgets"];
+function uiAiRoutes(r, ctx, deps = {}) {
+  const root = ctx.root;
+  const env = deps.env ?? process.env;
+  const keys = () => deps.keys ?? defaultKeyStore();
+  const file = () => join8(orgPackDirOf(root), "runtime.yaml");
+  const rel = () => relative(root, file()).split(sep).join("/");
+  const build = async (op, type, settings) => {
+    if (deps.provider)
+      return deps.provider(type, settings);
+    const make = await providerFactoryFor(op, type);
+    return make?.(settings);
+  };
+  return r.add("GET", "/api/settings/ai", async () => {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const rt = op.runtime;
+    const model = rt.adapters.model;
+    const keyEnv = typeof model?.settings.keyEnv === "string" ? model.settings.keyEnv : void 0;
+    return {
+      status: 200,
+      body: {
+        // The assistant atticus probe measured here, when one was (ADR 0124 addendum A-probe).
+        runs: whatRunsWhere(rt, { probes: (await readProbes(root)).results }),
+        ai: rt.ai,
+        modes: rt.modes,
+        assistants: ASSISTANTS.map((id) => ({
+          id,
+          name: ASSISTANT_FORMATS[id].name,
+          allowed: rt.assistants.allowed.includes(id),
+          default: rt.assistants.default === id
+        })),
+        providers: [
+          ...Object.entries(PROVIDER_SETTINGS).map(([type, settings]) => ({
+            type,
+            settings: [...settings]
+          })),
+          // The org pack's model-provider plugins, with what each takes (ADR 0121 item 4).
+          ...op.modelProviders.map(({ manifest: m }) => ({
+            type: m.id,
+            settings: [
+              ...COMMON_SETTINGS,
+              ...m.auth === "none" ? [] : ["keyEnv"],
+              ...m.settings
+            ],
+            plugin: true,
+            pinned: !!m.sha256
+          }))
+        ],
+        model: model ? { type: model.type, settings: model.settings } : null,
+        // Whether the key's variable is set here, by name: its value is never read out.
+        keySet: keyEnv ? !!env[keyEnv]?.trim() || !!keys().get(keyEnv) : false,
+        models: rt.models,
+        budgets: rt.budgets,
+        path: rel()
+      }
+    };
+  }).add("PUT", "/api/settings/ai", async ({ body }) => {
+    const b = body ?? {};
+    const text = existsSync(file()) ? await readFile6(file(), "utf8") : void 0;
+    const raw = text !== void 0 ? (0, import_yaml5.parse)(text) ?? {} : structuredClone(DEFAULT_RUNTIME);
+    for (const f of FIELDS)
+      if (b[f] !== void 0)
+        raw[f] = b[f];
+    if (b.model !== void 0) {
+      const adapters = { ...raw.adapters ?? {} };
+      if (b.model === null)
+        delete adapters.model;
+      else {
+        const m = b.model;
+        const settings = Object.fromEntries(Object.entries(m.settings ?? {}).filter(([, v]) => v !== "" && v !== void 0));
+        for (const [name, v] of Object.entries(settings))
+          for (const one of Array.isArray(v) ? v : [v])
+            if (typeof one === "string" && looksLikeKey(one))
+              throw unprocessable(`${name} looks like a key. A key never goes in runtime.yaml: keep it in an environment variable (or the OS's credential store) and give that variable's name as keyEnv.`);
+        if (settings.keyEnv !== void 0 && !ENV_NAME.test(String(settings.keyEnv)))
+          throw unprocessable(`keyEnv is the name of an environment variable, such as ATTICUS_MODEL_KEY.`);
+        adapters.model = { type: m.type, settings };
+      }
+      raw.adapters = adapters;
+    }
+    const checked = Runtime.safeParse(raw);
+    if (!checked.success)
+      throw unprocessable(checked.error.issues.map((i) => `${i.path.join(".") || "runtime.yaml"}: ${i.message}`).join("; "));
+    const header = (text ?? "").split(/\r?\n/).filter((l, i, a) => a.slice(0, i + 1).every((x) => x.startsWith("#")));
+    await writeFileAtomic(file(), `${header.length ? `${header.join("\n")}
+` : ""}${(0, import_yaml5.stringify)(raw, { lineWidth: 0 })}`);
+    return {
+      status: 200,
+      body: {
+        ok: true,
+        path: rel(),
+        note: `Saved ${rel()}. Commit it in a pull request: the org pack is reviewed like code.`
+      }
+    };
+  }).add("POST", "/api/settings/ai/key", async ({ body }) => {
+    const b = body ?? {};
+    const name = typeof b.name === "string" ? b.name.trim() : "";
+    const value = typeof b.value === "string" ? b.value.trim() : "";
+    if (!ENV_NAME.test(name))
+      throw unprocessable("The key's name is keyEnv's: a variable's name, such as ATTICUS_MODEL_KEY.");
+    if (!value)
+      throw unprocessable("No key was given.");
+    keys().set(name, value);
+    return { status: 200, body: { ok: true, name } };
+  }).add("POST", "/api/settings/ai/test", async () => {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const model = op.runtime.adapters.model;
+    if (!model || model.type === "mock")
+      throw conflict("No model provider is set in runtime.yaml: choose one first.");
+    const started = Date.now();
+    try {
+      const p = await build(op, model.type, model.settings);
+      if (!p)
+        return {
+          status: 200,
+          body: { ok: false, error: `No ${model.type} provider is installed here.` }
+        };
+      await p.complete({
+        system: "You are checking that a connection works.",
+        prompt: "Reply with the word OK.",
+        maxOutputTokens: 5
+      });
+      return { status: 200, body: { ok: true, model: p.model, ms: Date.now() - started } };
+    } catch (e) {
+      return {
+        status: 200,
+        body: { ok: false, error: e instanceof Error ? e.message : String(e) }
+      };
+    }
+  });
+}
+
+// packages/cli/dist/ui-api-documents.js
+var MAX_FILE = 15 * 1024 * 1024;
+function uiDocumentRoutes(r, ctx) {
+  const root = ctx.root;
+  const changed = (path) => ctx.events.publish({ type: "file.changed", path });
+  return r.add("GET", "/api/knowledge/documents", async () => {
+    const { listDocuments } = await import("./chunk-7URGP4DD.js");
+    return { status: 200, body: api_exports.DocumentList.parse(await listDocuments(root)) };
+  }).add("POST", "/api/knowledge/documents", async ({ body }) => {
+    const b = api_exports.AttachFileRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Send the file's name and its bytes in base64.");
+    const bytes = new Uint8Array(Buffer.from(b.data.content, "base64"));
+    if (bytes.length > MAX_FILE)
+      throw new HttpError(413, "The file is too large", "Add a file of 15 MB or less.");
+    const { addToInbox } = await import("./chunk-NNUASOAA.js");
+    const res = await addToInbox(root, [{ name: b.data.name, bytes }]);
+    if (!res.added.length)
+      throw new HttpError(422, "Atticus can't add that", res.refused[0]?.why ?? "", {
+        lines: res.refused.map((x) => `${x.name}: ${x.why}`)
+      });
+    for (const a of res.added)
+      changed(a.path);
+    return { status: 201, body: api_exports.AddDocumentResult.parse(res) };
+  }, { maxBody: Math.ceil(MAX_FILE * 4 / 3) + 64 * 1024 }).add("POST", "/api/changes/{changeId}/inputs/{name}/promote", async ({ params }) => {
+    const { AttachError, promoteChangeInput } = await import("./chunk-Y7KBQ4BD.js");
+    try {
+      const res = await promoteChangeInput(root, params.changeId, params.name);
+      changed(res.path);
+      return { status: 200, body: api_exports.PromoteResult.parse(res) };
+    } catch (e) {
+      if (e instanceof AttachError)
+        throw e.code === "not-found" ? notFound(e.message) : new HttpError(422, "Atticus can't copy that", e.message);
+      throw e;
+    }
+  });
+}
+
+// packages/cli/dist/ui-api-repos.js
+function uiRepoRoutes(r, ctx) {
+  const root = ctx.root;
+  return r.add("GET", "/api/repos/branches", async () => {
+    const { repoBranches } = await import("./chunk-YLAJAI2W.js");
+    return { status: 200, body: api_exports.RepoBranchesList.parse(await repoBranches(root)) };
+  }).add("GET", "/api/repos/compare", async ({ query }) => {
+    const branch = query.get("branch")?.trim() ?? "";
+    if (!branch)
+      throw badRequest("Say which branch: ?branch=<name>.");
+    const { compareBranch } = await import("./chunk-YLAJAI2W.js");
+    const c = await compareBranch(root, branch);
+    if (!c)
+      throw notFound(`${branch} hasn't been scanned beside the baseline yet.`);
+    return { status: 200, body: api_exports.BranchCompare.parse(c) };
+  }).add("PUT", "/api/repos/{repoId}/branches", async ({ params, body }) => {
+    const b = api_exports.EditRepoBranchesRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Send defaultBranch and branches as branch names.");
+    const { editRepoBranches, RepoEditError } = await import("./chunk-YLAJAI2W.js");
+    try {
+      const file = await editRepoBranches(root, params.repoId, b.data);
+      ctx.events.publish({ type: "file.changed", path: file });
+      return {
+        status: 200,
+        body: {
+          file,
+          note: `${file} changed: commit it in a pull request. Run atticus workspace sync if the default branch changed.`
+        }
+      };
+    } catch (e) {
+      if (e instanceof RepoEditError)
+        throw e.code === "not-found" ? notFound(e.message) : badRequest(e.message);
+      throw e;
+    }
+  }).add("PUT", "/api/repos/{repoId}/description", async ({ params, body }) => {
+    const b = api_exports.EditRepoDescriptionRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Send what the repo is as text, or accept: true to confirm the draft, or reject: true to drop it.");
+    const { editRepoDescription, RepoEditError } = await import("./chunk-YLAJAI2W.js");
+    try {
+      const r2 = await editRepoDescription(root, params.repoId, b.data);
+      ctx.events.publish({ type: "file.changed", path: r2.file });
+      return {
+        status: 200,
+        body: {
+          file: r2.file,
+          ...r2.description ? { description: r2.description } : {},
+          note: r2.description ? `${r2.file} changed: commit it in a pull request. Every reading prompt, question and view of ${params.repoId} now says what it is.` : `${r2.file} changed: commit it in a pull request. Nothing says what ${params.repoId} is now.`
+        }
+      };
+    } catch (e) {
+      if (e instanceof RepoEditError)
+        throw e.code === "not-found" ? notFound(e.message) : badRequest(e.message);
+      throw e;
+    }
+  });
+}
+
+// packages/cli/dist/ui-api-cockpit.js
+function uiCockpitRoutes(r, ctx) {
+  return r.add("GET", "/api/changes/{changeId}/cockpit", async ({ params }) => {
+    const { cockpit } = await import("./chunk-PKCMRPPB.js");
+    try {
+      return {
+        status: 200,
+        body: api_exports.ChangeCockpit.parse(await cockpit(ctx.root, params.changeId))
+      };
+    } catch (e) {
+      if (e instanceof Error && e.name === "ChangeFileError")
+        throw notFound(`There is no change ${params.changeId}.`);
+      throw e;
+    }
+  }).add("GET", "/api/past-changes", async ({ query }) => {
+    const { changeAboutText, similarChanges } = await import("./chunk-MF7QH4AX.js");
+    const change = query.get("change");
+    const text = change ? await changeAboutText(ctx.root, change) : query.get("text")?.trim();
+    if (change && !text)
+      throw notFound(`There is no change ${change}.`);
+    if (!text)
+      throw badRequest("Say what the new change is about: ?text=<its title or brief>, or ?change=<a change's id>.");
+    const limit = Number(query.get("limit") ?? 5);
+    return {
+      status: 200,
+      body: api_exports.SimilarChanges.parse(await similarChanges(ctx.root, text.slice(0, 2e4), {
+        limit: Number.isInteger(limit) && limit > 0 && limit <= 20 ? limit : 5
+      }))
+    };
+  }).add("POST", "/api/changes/{changeId}/like", async ({ params, body }) => {
+    const b = api_exports.AttachPastChangeRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which archived change: { like: <its folder or id> }.");
+    const { attachPastChange, findPastChange } = await import("./chunk-MF7QH4AX.js");
+    const folder = await findPastChange(ctx.root, b.data.like);
+    if (!folder)
+      throw notFound(`There is no archived change ${b.data.like}.`);
+    const { AttachError } = await import("./chunk-Y7KBQ4BD.js");
+    try {
+      const name = await attachPastChange(ctx.root, params.changeId, folder, ctx.user);
+      ctx.events.publish({ type: "file.changed", path: `inputs/${name}` });
+      return {
+        status: 201,
+        body: api_exports.AttachPastChangeResult.parse({ like: folder, file: `inputs/${name}` })
+      };
+    } catch (e) {
+      if (e instanceof AttachError)
+        throw e.code === "not-found" ? notFound(e.message) : new HttpError(422, "Atticus can't attach that", e.message);
+      throw e;
+    }
+  });
+}
+
+// packages/cli/dist/ui-api-audit.js
+var REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+var repoOf = (v) => {
+  if (!REPO.test(v))
+    throw badRequest(`${JSON.stringify(v)} isn't a repo name.`);
+  return v;
+};
+async function itemsWithLines(root, repo, items) {
+  const text = await auditLines(root, repo, items);
+  return items.map((i) => ({
+    ...i,
+    lines: i.cites.map((c) => {
+      const t = text.get(c);
+      return { cite: c, ...t ? { text: t.length > 300 ? `${t.slice(0, 297)}...` : t } : {} };
+    })
+  }));
+}
+var ofDraw = (audit, drawn) => {
+  const byId = new Map(audit.items.map((i) => [i.id, i]));
+  return drawn.map((d) => byId.get(d.id) ?? d);
+};
+function uiAuditRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return r.add("GET", "/api/facts/{repo}/audit", async ({ params, query }) => {
+    const repo = repoOf(params.repo);
+    const seed = query.get("seed") || void 0;
+    const sizeText = query.get("size");
+    const size = sizeText ? Number(sizeText) : void 0;
+    if (size !== void 0 && (!Number.isInteger(size) || size < 1 || size > 100))
+      throw badRequest("size is a whole number from 1 to 100.");
+    const p = await prepareAudit(ctx.root, repo, {
+      ...seed ? { seed } : {},
+      ...size ? { size } : {},
+      now
+    });
+    const command = (s, n) => `atticus verify audit ${repo} --seed ${s} --size ${n}`;
+    if ("refused" in p) {
+      const body2 = {
+        repo,
+        file: `${factsRelOf(ctx.root)}/${repo}.audit.yaml`,
+        seed: seed ?? "",
+        size: size ?? 10,
+        items: [],
+        refused: p.refused,
+        ...p.unverified ? { unverified: p.unverified } : {},
+        command: `atticus verify audit ${repo}`
+      };
+      return { status: 200, body: body2 };
+    }
+    const precision = await precisionOf(ctx.root, repo, p.audit, p.facts);
+    const commit = [...new Set(p.facts.map((f) => f.commit))].sort()[0];
+    const body = {
+      repo,
+      file: p.fileRel,
+      seed: p.seed,
+      size: p.size,
+      defaultSeed: defaultAuditSeed(repo, commit),
+      items: await itemsWithLines(ctx.root, repo, ofDraw(p.audit, p.drawn)),
+      precision: { facts: precision.facts, links: precision.links },
+      command: command(p.seed, p.size)
+    };
+    return { status: 200, body };
+  }).add("POST", "/api/facts/{repo}/audit", async ({ params, body }) => {
+    const repo = repoOf(params.repo);
+    const b = api_exports.AuditAnswerRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say the draw and the answers: { seed, size, answers: [{ id, answer, note }] }.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const p = await prepareAudit(ctx.root, repo, {
+      seed: b.data.seed,
+      size: b.data.size,
+      now
+    });
+    if ("refused" in p) {
+      if (p.refused === "no-facts")
+        throw notFound(p.lines.join(" "));
+      throw new HttpError(422, "Atticus can't audit this repo yet", p.lines.join(" "));
+    }
+    const inDraw = new Set(p.drawn.map((d) => d.id));
+    const outside = b.data.answers.filter((a) => !inDraw.has(a.id)).map((a) => a.id);
+    if (outside.length)
+      throw new HttpError(422, "Not in this sample", `Not in this sample: ${outside.join(", ")}. Answer the items the draw lists.`);
+    const answers = new Map(b.data.answers.map((a) => [
+      a.id,
+      { answer: a.answer, ...a.note ? { note: a.note } : {} }
+    ]));
+    answerAudit(p.audit, answers, ctx.user, p.now);
+    await writeAudit(ctx.root, repo, p.audit);
+    ctx.events.publish({ type: "file.changed", path: p.fileRel });
+    const precision = await precisionOf(ctx.root, repo, p.audit, p.facts);
+    const result = {
+      file: p.fileRel,
+      answered: p.audit.items.filter((i) => i.answer).length,
+      open: p.audit.items.filter((i) => !i.answer).length,
+      items: await itemsWithLines(ctx.root, repo, ofDraw(p.audit, p.drawn)),
+      precision: { facts: precision.facts, links: precision.links },
+      commit: `git add ${p.fileRel} && git commit -m "${repo}: a person's sample audit answers"`
+    };
+    return { status: 200, body: result };
+  });
+}
+
+// packages/cli/dist/ui-api-outside.js
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+var SPECS = /* @__PURE__ */ new Set(["openapi", "swagger"]);
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var OUTSIDE_ADD_SPEC = (id) => [
+  `atticus intake add <the ${id} spec file>`,
+  "atticus intake list",
+  "atticus triage"
+];
+async function outsideView(root) {
+  const quiet = { out: () => void 0, err: () => void 0 };
+  const { op, records, inputs } = await intakeContext(root, quiet);
+  const systems = outsideProfileSystems(op);
+  const estate = await estateFacts(root, op, "");
+  const facts = /* @__PURE__ */ new Map();
+  for (const r of estate.repos)
+    for (const f of r.facts)
+      facts.set(`${r.repo}\0${f.id}`, f);
+  const joined = estateJoinOf(op, estate.repos, estate.targets);
+  const repos = joinReposOf(op, estate.repos, componentRenames(estate.repos, op));
+  const { maps: sharedMaps } = await readSharedMaps(root);
+  const sharedJoin = sharedMaps.length ? joinSharedMaps({ outside: joined.outside ?? [], repos, maps: sharedMaps, systems }) : { matches: [], gaps: [], asks: [] };
+  const specs = /* @__PURE__ */ new Map();
+  for (const d of inputs.documents) {
+    if (!d.id || d.supersededBy || !SPECS.has(d.classification))
+      continue;
+    const system = systems.find((s) => s.id === d.systems[0]);
+    if (!system || specs.has(system.id))
+      continue;
+    const body = await readFile7(join9(inputsDirOf(root), ...d.path.split("/").slice(1)), "utf8");
+    const spec = readVendorSpec(d.path, body, system.id);
+    if (spec)
+      specs.set(system.id, spec);
+  }
+  const vendors = systems.flatMap((s) => {
+    const spec = specs.get(s.id);
+    if (!spec)
+      return [];
+    return [
+      {
+        system: s.id,
+        boundary: "internal",
+        names: [s.name, ...s.aliases],
+        hosts: [.../* @__PURE__ */ new Set([...spec.hosts, ...hostAliases(s.aliases)])],
+        operations: spec.operations.map((o) => ({
+          id: o.id,
+          method: o.method,
+          path: o.path,
+          fullPath: o.fullPath,
+          cite: o.cite
+        }))
+      }
+    ];
+  });
+  const matched = vendors.length ? joinVendorOperations({
+    repos,
+    vendors,
+    targets: estate.targets,
+    ...joinConventions(op)
+  }) : { matches: [], gaps: [], asks: [] };
+  const catalog = records.length ? records : (await readCatalog(join9(catalogDirOf(root), "generated"), { cacheRoot: root })).records;
+  const ifaces = catalog.filter((r) => r.kind === "Interface");
+  const componentsOf = (id) => /* @__PURE__ */ new Set([
+    id,
+    ...catalog.filter((r) => r.kind === "Component" && r.system === id).map((r) => r.id)
+  ]);
+  const open = await listQuestions(root, { state: "open" }).then((l) => l.questions, () => []);
+  const callOf = (e) => {
+    const f = facts.get(`${e.repo}\0${e.fact}`);
+    const x = f?.kind === "call" ? f : void 0;
+    return {
+      repo: e.repo,
+      ...e.component ? { component: e.component } : {},
+      fact: e.fact,
+      at: e.at,
+      ...x?.method ? { method: x.method.toUpperCase() } : {},
+      ...x?.path ? { path: x.path } : {}
+    };
+  };
+  const out = systems.map((s) => {
+    const names = new Set([s.id, s.name, ...s.aliases].map(factIdPart));
+    const comps = componentsOf(s.id);
+    const callers = /* @__PURE__ */ new Map();
+    const add = (c, seen) => {
+      const k = `${c.repo}|${c.at}`;
+      const had = callers.get(k);
+      if (had) {
+        if (!had.seen.includes(seen))
+          had.seen = [...had.seen, seen].sort();
+        Object.assign(had, { ...c, ...had, seen: had.seen });
+      } else
+        callers.set(k, { ...c, seen: [seen] });
+    };
+    for (const o of joined.outside ?? [])
+      if (names.has(factIdPart(o.target)))
+        add(callOf(o.call), "join");
+    for (const r of ifaces) {
+      if (!comps.has(r.to))
+        continue;
+      for (const e of r.evidence)
+        if (e.side !== "callee" && e.source !== "config" && e.repo && e.path && e.line !== void 0)
+          add({
+            repo: e.repo,
+            component: r.from,
+            at: `${e.path}:${e.line}`,
+            ...r.method ? { method: r.method } : {},
+            path: r.normalizedPath,
+            interface: r.id
+          }, "interface");
+    }
+    for (const g of [...matched.gaps, ...matched.asks].filter((x) => x.vendor === s.id))
+      add(callOf(g.call), "spec");
+    for (const m of matched.matches.filter((x) => x.vendor === s.id)) {
+      add({ ...callOf(m.call), operation: m.operation }, "spec");
+      if (m.direct || !m.route)
+        continue;
+      const route = m.route;
+      for (const j of joined.joins)
+        if (j.entry.repo === route.repo && j.entry.fact === route.fact)
+          add({
+            ...callOf(j.call),
+            operation: m.operation,
+            through: { repo: route.repo, at: route.at }
+          }, "spec");
+    }
+    for (const m of sharedJoin.matches.filter((x) => x.system === s.id))
+      add({
+        ...callOf(m.call),
+        entry: { team: m.team, repo: m.entry.repo, fact: m.entry.fact, at: m.entry.at }
+      }, "shared");
+    for (const g of sharedJoin.gaps.filter((x) => x.system === s.id))
+      add(callOf(g.call), "shared");
+    const list = [...callers.values()].sort((a, b) => cmp(a.repo, b.repo) || cmp(a.at, b.at));
+    const spec = specs.get(s.id);
+    const map = sharedMaps.find((m) => m.system === s.id);
+    const lines = new Set(list.map((c) => `${c.repo}|${c.at}`));
+    const named = [s.id, s.name, ...s.aliases].map((n) => n.toLowerCase());
+    const questions = open.filter((q) => named.some((n) => q.question.toLowerCase().includes(n)) || q.options.some((o) => named.some((n) => o.label.toLowerCase().includes(n))) || q.evidence.some((e) => lines.has(`${q.repo}|${e}`))).map((q) => ({ id: q.id, repo: q.repo, question: q.question })).sort((a, b) => cmp(a.id, b.id));
+    return {
+      id: s.id,
+      name: s.name,
+      boundary: s.boundary,
+      ...s.owner ? { owner: s.owner } : {},
+      aliases: [...s.aliases],
+      callers: list,
+      ...spec ? {
+        spec: {
+          path: spec.path,
+          ...spec.title ? { title: spec.title } : {},
+          ...spec.version ? { version: spec.version } : {},
+          operations: spec.operations.map((o) => ({
+            id: o.id,
+            method: o.method,
+            path: o.fullPath,
+            cite: o.cite,
+            calls: list.filter((c) => c.operation === o.id).length
+          }))
+        }
+      } : {},
+      unmatched: matched.gaps.filter((g) => g.vendor === s.id).map((g) => ({ ...callOf(g.call), seen: ["spec"], message: g.message })),
+      ambiguous: matched.asks.filter((a) => a.vendor === s.id).map((a) => ({ ...callOf(a.call), seen: ["spec"], candidates: a.candidates })),
+      questions,
+      ...spec ? {} : { addSpec: OUTSIDE_ADD_SPEC(s.id) },
+      ...map ? {
+        shared: {
+          team: map.team,
+          name: map.name,
+          commit: map.commit,
+          importedAt: map.file.importedAt,
+          entries: map.repos.flatMap((r) => r.facts.flatMap((f) => f.kind === "entry" ? [
+            {
+              repo: r.repo,
+              component: factIdPart(f.component ?? r.component ?? r.repo),
+              fact: f.id,
+              ...f.method ? { method: f.method.toUpperCase() } : {},
+              path: f.path,
+              at: `${f.cite.file}:${f.cite.line}`,
+              ...f.commit ? { commit: f.commit } : {},
+              calls: list.filter((c) => c.entry?.repo === r.repo && c.entry.fact === f.id).length
+            }
+          ] : [])).sort((a, b) => cmp(a.repo, b.repo) || cmp(a.at, b.at)),
+          unmatched: sharedJoin.gaps.filter((g) => g.system === s.id).map((g) => ({ ...callOf(g.call), seen: ["shared"], message: g.message }))
+        }
+      } : {}
+    };
+  });
+  return { systems: out, notes: estate.notes };
+}
+function uiOutsideRoutes(r, ctx) {
+  return r.add("GET", "/api/outside", async () => ({
+    status: 200,
+    body: await outsideView(ctx.root)
+  }));
+}
+
+// packages/cli/dist/ui-api-stages.js
+import { stat as stat4 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+var ID2 = /^[a-z0-9][a-z0-9._-]{0,99}$/;
+function findingOptions(f) {
+  const open = f.state === "open";
+  const issue = f.kind === "issue";
+  return {
+    fix: f.fix.text,
+    apply: open && issue,
+    dismiss: open && issue,
+    waive: open && issue && f.severity === "blocking" && f.waivable,
+    ...open && f.question ? { ask: { text: f.question.text, owner: f.question.owner } } : {}
+  };
+}
+var exists2 = (p) => stat4(p).then(() => true, () => false);
+var slashOf = (stage, change) => `/atticus-${stage} ${change}`;
+async function gateOf(root, change, stage) {
+  const problems = [];
+  let gate;
+  try {
+    gate = stageGate(await loadChangeContext(root), stage);
+  } catch (e) {
+    problems.push({
+      file: "org-pack",
+      message: `The org pack doesn't load, so the stage's gate isn't known: ${String(e.message ?? e).split("\n")[0]}`
+    });
+  }
+  if (!gate && (await reviewedGates(root, change)).includes(STAGE_PHASE[stage]))
+    gate = STAGE_PHASE[stage];
+  return { gate, problems };
+}
+async function latest(root, change, gate) {
+  if (!gate)
+    return { round: null, findings: [], bad: [] };
+  const rounds = await roundsOf(root, change, gate);
+  const round = rounds.at(-1);
+  if (round === void 0)
+    return { round: null, findings: [], bad: [] };
+  const r = await readRound(root, change, gate, round);
+  return { round, findings: r.findings, bad: r.bad };
+}
+var view = (c) => ({
+  question: c.question,
+  text: c.text,
+  by: c.by,
+  at: c.at,
+  read: c.read
+});
+async function stageReviewView(root, change, stage) {
+  const rel = `${changesRelOf(root)}/${change}`;
+  const { gate, problems } = await gateOf(root, change, stage);
+  const l = await latest(root, change, gate);
+  for (const b of l.bad)
+    problems.push({ file: `${rel}/${b.path}`, message: b.message });
+  const comments = await stageComments(root, change, stage);
+  const { loop, present, file } = await readStageLoop(changeFolder(root, change), change, stage);
+  const order = { blocking: 0, gap: 1, risk: 2, idea: 3 };
+  const proposals = gate && l.round !== null ? await readProposals(root, change, gate, l.round) : [];
+  const findings = l.findings.map((s) => {
+    const fileRel = `${rel}/${s.path}`;
+    const p = s.finding.state === "open" ? proposals.find((x) => x.finding === s.finding.id) : void 0;
+    return {
+      finding: s.finding,
+      file: fileRel,
+      options: findingOptions(s.finding),
+      comments: comments.comments.filter((c) => c.about === fileRel).map(view),
+      ...p ? {
+        proposal: {
+          claim: p.claim,
+          by: p.by,
+          at: p.at,
+          ...p.reason ? { reason: p.reason } : {}
+        }
+      } : {}
+    };
+  }).sort((a, b) => Number(a.finding.state !== "open") - Number(b.finding.state !== "open") || order[a.finding.severity] - order[b.finding.severity] || a.finding.id.localeCompare(b.finding.id));
+  const questions = [];
+  for (const id of comments.others) {
+    const q = await readQuestion(root, id).catch((e) => {
+      problems.push({ file: `questions/${id}.yaml`, message: String(e.message ?? e) });
+      return void 0;
+    });
+    if (q && q.state !== "retired")
+      questions.push(q);
+  }
+  questions.sort((a, b) => Number(a.state !== "open") - Number(b.state !== "open"));
+  return {
+    change,
+    stage,
+    gate: gate ?? null,
+    round: l.round,
+    loop: {
+      file: `${rel}/${file}`,
+      present,
+      ...present ? { state: loop.state, iteration: loop.iteration } : {}
+    },
+    findings,
+    questions,
+    next: { command: rerunOf(stage, change), slash: slashOf(stage, change) },
+    problems
+  };
+}
+function tabOf(v) {
+  const r = api_exports.StageTab.safeParse(v);
+  if (!r.success)
+    throw badRequest(`${JSON.stringify(v)} isn't a stage: feature, architecture or stories.`);
+  return r.data;
+}
+function uiStageRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const changeOf = async (v) => {
+    if (!ID2.test(v))
+      throw badRequest(`${JSON.stringify(v)} isn't a change id.`);
+    if (!await exists2(join10(changeFolder(ctx.root, v), "change.yaml")))
+      throw notFound(`There is no change ${v}.`);
+    return v;
+  };
+  return r.add("GET", "/api/changes/{changeId}/stages/{stage}", async ({ params }) => {
+    const stage = tabOf(params.stage);
+    const change = await changeOf(params.changeId);
+    return { status: 200, body: await stageReviewView(ctx.root, change, stage) };
+  }).add("POST", "/api/changes/{changeId}/stages/{stage}/comments", async ({ params, body }) => {
+    const stage = tabOf(params.stage);
+    const change = await changeOf(params.changeId);
+    const b = api_exports.StageCommentRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which finding and write the comment: { finding, text }.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const v = await stageReviewView(ctx.root, change, stage);
+    const hits = v.findings.filter((f2) => f2.finding.id === b.data.finding && (!b.data.gate || f2.finding.gate === b.data.gate));
+    if (!hits.length)
+      throw notFound(`The ${stage} stage of ${change} has no finding ${b.data.finding} in ${v.gate ? `the ${v.gate} gate's latest round` : "any gate"}.`);
+    const f = hits[0];
+    let written;
+    try {
+      written = await commentOnFinding(ctx.root, {
+        change,
+        stage,
+        finding: {
+          id: f.finding.id,
+          rule: f.finding.rule,
+          summary: f.finding.summary,
+          artifact: f.finding.artifact,
+          ...f.finding.locator.line ? { line: f.finding.locator.line } : {},
+          file: f.file
+        },
+        text: b.data.text,
+        by: ctx.user,
+        at: now().toISOString()
+      });
+    } catch (e) {
+      if (e instanceof PlannerError && e.code === "refused")
+        throw conflict(e.message);
+      if (e instanceof PlannerError)
+        throw new HttpError(422, "Atticus refused", e.message);
+      throw e;
+    }
+    for (const p of written.files)
+      ctx.events.publish({ type: "file.changed", path: p });
+    const q = written.question;
+    const result = {
+      comment: {
+        question: q.id,
+        text: q.answer.text,
+        by: q.answer.by,
+        at: q.answer.at,
+        read: false
+      },
+      files: written.files,
+      commit: `git add ${written.files.join(" ")} && git commit -m "${change}: a comment on ${f.finding.id}"`,
+      next: v.next
+    };
+    return { status: 200, body: result };
+  });
+}
+
+// packages/cli/dist/ui-commands.js
+function catalogMayHaveChanged(root, path) {
+  const p = path.replace(/^\.\/?/, "").replace(/\/+$/, "");
+  const near = (dir) => {
+    const rel = relative2(root, dir).split(sep2).join("/");
+    if (rel.startsWith("..") || isAbsolute(rel))
+      return true;
+    return p === "" || p === rel || p.startsWith(rel + "/") || rel.startsWith(p + "/");
+  };
+  return near(catalogDirOf(root)) || near(orgPackDirOf(root));
+}
+async function startUi(root, o = {}, deps = {}) {
+  const srv = await startServer({
+    root,
+    port: o.port ?? DEFAULT_PORT,
+    ...o.embed ? { embed: o.embed } : {},
+    ...o.full ? { full: true } : {},
+    ...o.token ? { token: o.token } : {},
+    staticDir: o.staticDir ?? uiDistDir(),
+    ...o.user ? { user: o.user } : {},
+    ...o.version ? { version: o.version } : {},
+    onRequest: (() => {
+      const log = createLog(root);
+      return (r) => {
+        const fields = { method: r.method, path: r.path, status: r.status, ms: r.ms };
+        if (r.error)
+          log.error("request", r.error, fields);
+        else if (r.status >= 500)
+          log.warn("request", fields);
+        else
+          log.debug("request", fields);
+      };
+    })(),
+    extend: (r, ctx) => {
+      const base = uiKnowRoutes(uiRunRoutes(uiRoutes(r, ctx, deps), ctx, deps), ctx, {
+        warm: o.warm === true
+      });
+      const views = uiGraphRoutes(uiAcrossRoutes(uiMeRoutes(base, ctx), ctx), ctx);
+      const specs = uiSpecRoutes(uiOnboardingRoutes(uiQuestionRoutes(views, ctx), ctx), ctx);
+      return uiStageRoutes(uiOutsideRoutes(uiAuditRoutes(uiFactsRoutes(uiTrustRoutes(uiCockpitRoutes(uiRepoRoutes(uiDocumentRoutes(uiAiRoutes(uiHistoryRoutes(uiModelRunRoutes(uiKnowledgeRoutes(uiCiteRoutes(specs, ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx);
+    }
+  });
+  keepCatalogsInMemory(true);
+  void readCatalog(join11(catalogDirOf(root), "generated"), { cacheRoot: root }).catch(() => void 0);
+  const stop = srv.events.listen((e) => {
+    const changed = e.type === "file.changed" && (typeof e.path !== "string" || catalogMayHaveChanged(root, e.path));
+    if (changed || e.type === "index.rebuilt")
+      forgetCatalogs();
+  });
+  const close = srv.close;
+  return Object.assign(srv, {
+    close: async () => {
+      stop();
+      keepCatalogsInMemory(false);
+      await close();
+    }
+  });
+}
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+function untilStopped(embedded, stdin = process.stdin, o = {}) {
+  return new Promise((resolve2) => {
+    const alive = o.alive ?? ((pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (e) {
+        return e.code === "EPERM";
+      }
+    });
+    const watch = o.parent !== void 0 ? setInterval(() => {
+      if (!alive(o.parent))
+        stop();
+    }, o.everyMs ?? 2e3) : void 0;
+    const stop = () => {
+      if (watch)
+        clearInterval(watch);
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      if (embedded) {
+        stdin.off("end", stop);
+        stdin.off("close", stop);
+        stdin.pause();
+      }
+      resolve2();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    if (embedded) {
+      stdin.once("end", stop);
+      stdin.once("close", stop);
+      stdin.on("data", () => void 0);
+      stdin.resume();
+    }
+  });
+}
+function startedLines(url, token, o) {
+  return [
+    `Atticus is running at ${url} (Ctrl+C stops it).`,
+    o.embed || o.parent !== void 0 ? "The session token isn't printed: the editor that started the app has it." : o.showToken ? `For assistants and scripts, the session token is ${token}` : "The page has the session token; --show-token prints it for an assistant or a script."
+  ];
+}
+async function uiCommand(root, o, io) {
+  const given = o.embed ? process.env.ATTICUS_UI_TOKEN : void 0;
+  delete process.env.ATTICUS_UI_TOKEN;
+  let srv;
+  try {
+    srv = await startUi(root, {
+      ...given ? { token: given } : {},
+      warm: true,
+      ...o.full ? { full: true } : {},
+      ...o.port !== void 0 ? { port: o.port } : {},
+      ...o.user ? { user: o.user } : {},
+      ...o.version ? { version: o.version } : {},
+      ...o.embed ? { embed: o.embed } : {}
+    });
+  } catch (e) {
+    const code = e.code;
+    io.err(code === "EADDRINUSE" ? `Port ${o.port ?? DEFAULT_PORT} is in use. Start with --port <another port>.` : `Couldn't start the app: ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  }
+  for (const l of startedLines(srv.url, srv.token, o))
+    io.out(l);
+  const p = srv.person;
+  io.out(p.source === "git" ? `You are ${p.handle}${p.name ? ` (${p.name})` : ""}, from your Git user.` : `You are ${p.handle}.`);
+  if (p.warning)
+    io.err(p.warning);
+  if (o.open)
+    openBrowser(srv.url);
+  await untilStopped(o.embed === "vscode", process.stdin, o.parent !== void 0 ? { parent: o.parent } : {});
+  await srv.close();
+  io.out("Stopped.");
+  return 0;
+}
+export {
+  catalogMayHaveChanged,
+  startUi,
+  startedLines,
+  uiCommand,
+  untilStopped
+};