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

package/dist/{chunk-JIITQXFB.js → chunk-LNWEWYCM.js}

@@ -3,52 +3,48 @@ 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-DPUYDDQG.js";
 import {
   historyEntry,
   listHistory
-} from "./chunk-G2B4ZQGH.js";
+} from "./chunk-3WON4G3M.js";
+import "./chunk-JYTIHTIK.js";
 import {
-  estimateOf
-} from "./chunk-FHH4I4ZV.js";
+  uiComponentTypeRoutes
+} from "./chunk-CG6CULP6.js";
 import {
-  changeArchive,
-  changeHandoff,
-  changeNew,
-  changeSync
-} from "./chunk-T2UYZSCQ.js";
+  answerAudit,
+  auditLines,
+  defaultAuditSeed,
+  precisionOf,
+  prepareAudit,
+  writeAudit
+} from "./chunk-7FUIVIBG.js";
+import {
+  listRuns,
+  partStates,
+  runTranscript
+} from "./chunk-BA2HUMDN.js";
 import {
-  HttpError,
-  badRequest,
-  conflict,
-  notFound,
-  startServer,
-  strParam,
   uiCiteRoutes
-} from "./chunk-2RMYG36Q.js";
-import "./chunk-RRTKKSLQ.js";
+} from "./chunk-WCEF7H6L.js";
 import {
   isHandoffStep
 } from "./chunk-4Q3NN7VF.js";
 import {
-  conformanceCommand
-} from "./chunk-V2YTAIQO.js";
-import {
-  outcomeList,
-  outcomeRecord,
-  releaseEvidenceCommand,
-  releaseForecastCommand,
-  releaseNotesCommand,
-  releasePlanCommand,
-  releaseSecurityCommand
-} from "./chunk-652QWTLZ.js";
+  estimateOf
+} from "./chunk-WFU77T3A.js";
 import {
   changeMapBody,
-  changeMapOf
-} from "./chunk-TDD55CJH.js";
+  changeMapOf,
+  targetFlowsOf
+} from "./chunk-GNWAOVFQ.js";
+import {
+  changeArchive,
+  changeHandoff,
+  changeNew,
+  changeReleasePrs,
+  changeSync
+} from "./chunk-COYN3UAN.js";
 import {
   isSandbox,
   learnCheck,
@@ -56,141 +52,253 @@ import {
   lessonsFor,
   readProgress,
   sandboxCreate
-} from "./chunk-TXLH6WHQ.js";
+} from "./chunk-ZQLRCA2V.js";
 import {
   defencesScan,
   evalRun
-} from "./chunk-XAKWMCXI.js";
+} from "./chunk-FVMPFCDS.js";
 import {
   listReports,
   readQuality
-} from "./chunk-CPA6HPVR.js";
+} from "./chunk-FYBF5MB2.js";
 import {
-  readServiceRequests
-} from "./chunk-BOHJZTEQ.js";
+  conformanceCommand
+} from "./chunk-G5YJBNDZ.js";
 import {
-  initiativeStatus,
-  readView
-} from "./chunk-MVZVGYXH.js";
+  outcomeList,
+  outcomeRecord,
+  releaseEvidenceCommand,
+  releaseForecastCommand,
+  releaseNotesCommand,
+  releasePlanCommand,
+  releaseSecurityCommand
+} from "./chunk-AZDITBCT.js";
+import {
+  readServiceRequests
+} from "./chunk-36RY7ZXM.js";
 import {
-  taskRun
-} from "./chunk-CSZ4C5N6.js";
-import "./chunk-CEXSU4S6.js";
-import "./chunk-FITWGOJ2.js";
+  runDone,
+  taskRun,
+  taskRunNotWaiting
+} from "./chunk-AOCWFA7T.js";
 import {
   executorsCheck,
   todoDone,
   todoRun,
   todoShow
-} from "./chunk-HLJAXMM4.js";
+} from "./chunk-ZFQMMU5Y.js";
 import {
   inputsSha256,
   loadExecutors
-} from "./chunk-QSXK2RGH.js";
+} from "./chunk-DDJPM5YX.js";
 import {
-  uiOnboardingRoutes
-} from "./chunk-EBEW3XXQ.js";
+  initiativeStatus,
+  readView
+} from "./chunk-2V2ZPQQU.js";
 import {
-  readCorrections
-} from "./chunk-CR3MTH32.js";
-import "./chunk-O3WI5KWW.js";
+  DecideError,
+  correctDecision,
+  decisionsView,
+  undoBatch
+} from "./chunk-UYLBRRFK.js";
 import {
-  readMe,
-  writeMe
-} from "./chunk-JBTK5OP2.js";
+  boxesOf,
+  candidatesOf,
+  uiLinkRoutes
+} from "./chunk-6DQYZU2W.js";
 import {
-  digestCommand
-} from "./chunk-7WD63HU2.js";
+  matchDone,
+  quotesOf,
+  readMatch,
+  runMatch
+} from "./chunk-QJCJOMW3.js";
+import "./chunk-3SSTNB4E.js";
+import "./chunk-JRVNXLZP.js";
+import {
+  copilotAcpAllowed
+} from "./chunk-LIJJCBQI.js";
+import "./chunk-26Z7OGQW.js";
+import "./chunk-OKUB6RJA.js";
+import {
+  filesUnder,
+  memoByFiles,
+  recheckNow,
+  uiFactsRoutes
+} from "./chunk-QOOEYDNJ.js";
+import {
+  HttpError,
+  badRequest,
+  conflict,
+  notFound,
+  startServer,
+  strParam
+} from "./chunk-HK3VOHIE.js";
+import {
+  safeMessage,
+  withFileLock
+} from "./chunk-THN26IEF.js";
+import "./chunk-LN77DXBM.js";
+import "./chunk-L4CESDPB.js";
+import "./chunk-U3NBK4EU.js";
+import "./chunk-455SYIIE.js";
 import {
   reconcileCommand
-} from "./chunk-R6XF6UR3.js";
+} from "./chunk-YZDZOEV4.js";
 import {
   sourcesAdd,
   sourcesSync
-} from "./chunk-PCVDV3UZ.js";
+} from "./chunk-HXXP2NTE.js";
 import {
   INPUTS_SOURCE_ID
-} from "./chunk-ABWHYWNI.js";
+} from "./chunk-D57MFJPP.js";
+import "./chunk-5QUOPNLN.js";
+import {
+  readRepos
+} from "./chunk-4TKVU2I2.js";
+import {
+  uiOnboardingRoutes
+} from "./chunk-PNQLCRSS.js";
+import "./chunk-3J5I7ZOU.js";
+import {
+  uiTrustRoutes
+} from "./chunk-4FOAYLI4.js";
+import {
+  contractCheckOf,
+  estateJoinOnFile,
+  stampOf
+} from "./chunk-GX74YWR7.js";
+import "./chunk-G6IQYM25.js";
+import "./chunk-LPV6T362.js";
+import {
+  digestCommand
+} from "./chunk-X2CUXTWU.js";
 import {
   baselineCommand,
   setupSteps
-} from "./chunk-YY6ZQQBP.js";
-import {
-  catalogRecords,
-  openChanges,
-  systemGuide
-} from "./chunk-B2WLAWNJ.js";
+} from "./chunk-GK4PYVEC.js";
 import {
   doctorChecks
-} from "./chunk-AIOQPLA5.js";
-import "./chunk-3G4YI4ZU.js";
-import "./chunk-YISXLPHN.js";
-import "./chunk-GDLULHTC.js";
+} from "./chunk-HGHRSF3E.js";
+import "./chunk-4B6BT75O.js";
 import {
-  handoffDone,
-  workspaceOpen,
-  workspaceSync
-} from "./chunk-4BN53TG3.js";
-import "./chunk-2VHF7OXM.js";
-import "./chunk-KEM4SDDP.js";
+  readMe,
+  writeMe
+} from "./chunk-UF4UHCIG.js";
 import {
-  critic,
-  criticStats,
-  findingAction
-} from "./chunk-6M5NK3K3.js";
-import "./chunk-LR3R6Z2A.js";
+  cancelTaskRunWait,
+  findTaskRunOfRun,
+  previewTaskRun,
+  raiseTaskPr,
+  readTaskRun,
+  readyTasksOf,
+  runReadyTasks,
+  saveTaskRun,
+  settleTaskPr,
+  stopAllBuilds,
+  taskRunOfRun
+} from "./chunk-Y6K3CJBU.js";
+import "./chunk-GIFMBCTW.js";
+import "./chunk-MD7KUEJ3.js";
 import {
-  planStories,
-  snowDraft,
-  snowSubmit
-} from "./chunk-AA6YULYB.js";
-import "./chunk-BWZ77RQT.js";
+  checkoutOf
+} from "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
+import {
+  intakeContext
+} from "./chunk-TQ4TG57V.js";
+import {
+  workspaceOpen,
+  workspaceSync
+} from "./chunk-IFHDV6KQ.js";
+import "./chunk-LQH4P45K.js";
+import "./chunk-P2VBXX7N.js";
 import {
   archiveGate,
   ciArchiveGate
-} from "./chunk-HITVBIJS.js";
+} from "./chunk-ZX7235KR.js";
 import {
   traceMatrix
-} from "./chunk-2ANOROX3.js";
-import "./chunk-65NYPGRC.js";
-import "./chunk-VOGCSYOI.js";
+} from "./chunk-EZIN5E5B.js";
+import "./chunk-3LZ6P5EP.js";
 import {
   scanCommand
-} from "./chunk-JGZCG5VM.js";
-import "./chunk-RVH5SUW5.js";
+} from "./chunk-NCB6656Z.js";
+import "./chunk-TYD6I4CZ.js";
 import {
   readChangeTasks,
-  readStory
-} from "./chunk-OT2O76OS.js";
+  readStory,
+  setTaskDone
+} from "./chunk-YWAKDNMH.js";
+import {
+  catalogRecords,
+  openChanges,
+  systemGuide
+} from "./chunk-FY3QIRTL.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-2HTEMYTB.js";
 import {
   ASSISTANT_FORMATS,
   readProbes,
   whatRunsWhere
-} from "./chunk-IPKHE5D6.js";
+} from "./chunk-3AQ2R5NL.js";
+import {
+  critic,
+  criticStats,
+  findingAction
+} from "./chunk-PTQ3ZALZ.js";
+import "./chunk-A2G72UI4.js";
+import {
+  planStories,
+  snowDraft,
+  snowSubmit
+} from "./chunk-I2A3Z5AK.js";
+import "./chunk-F6H2RJ3N.js";
 import {
+  CORRECTIONS_FILE,
+  FEATURE_FILE,
   NEEDS_FILE,
   PlannerError,
   SYNC_FILE,
+  SnowFillError,
+  Stroke,
   TARGET_DIR,
+  addCorrection,
+  applyStroke,
   codeFactRecords,
   commentOnFinding,
   conflictTouches,
+  draftItems,
+  draftProvenance,
+  drawnStrokes,
+  fillSnowFields,
+  loadEstate,
   markNeed,
   mergeDelta,
   plainWhy,
+  planSketchWrite,
+  readCorrections,
   readDeltas,
   readKnowledgeApplies,
   readNeeds,
   readStageLoop,
+  recordPersonSave,
+  removeCorrection,
+  renderFeature,
   setKnowledgeStatus,
+  sketchFingerprint,
   stageComments,
-  stageGate
-} from "./chunk-CKSITVS4.js";
+  stageGate,
+  writeSketch
+} from "./chunk-BEPCKDCP.js";
 import {
+  FeaturePlacement,
+  STAGES,
   STAGE_PHASE,
   fieldNames,
   rerunOf
-} from "./chunk-L6SGQIR3.js";
+} from "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-VOGCSYOI.js";
 import {
   layerRules,
   loadConstitution,
@@ -203,8 +311,9 @@ import {
   readStoryIndex,
   reviewedGates,
   roundsOf
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-K332XW7K.js";
 import {
+  ChangeOwnersError,
   artifactFiles,
   artifactPhase,
   changeFolder,
@@ -214,19 +323,27 @@ import {
   detectConflicts,
   liveHandoff,
   loadChangeContext,
-  requiredArtifacts
-} from "./chunk-XY3P7JW7.js";
-import "./chunk-4AK7IBVP.js";
+  requiredArtifacts,
+  setChangeOwners
+} from "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
 import {
   fileStepStore,
   manualAdapter,
   stepOfProvisional
-} from "./chunk-7JUKDRSZ.js";
+} from "./chunk-4KNOJC6J.js";
 import {
+  componentRenames,
+  estateFacts,
+  estateRepos,
   forgetCatalogs,
+  hostAliases,
+  joinReposOf,
   keepCatalogsInMemory,
-  readCatalog
-} from "./chunk-27NKUS3X.js";
+  outsideProfileSystems,
+  readCatalog,
+  targetPicker
+} from "./chunk-4SLBCEPD.js";
 import {
   OrgPackProposal,
   SNAPSHOT_FILE,
@@ -250,106 +367,128 @@ import {
   snapshotDates,
   snapshotSources,
   writeReview
-} from "./chunk-L24C55VN.js";
+} from "./chunk-64AADMTW.js";
 import {
   NoSuchNode,
-  applyCorrections,
   buildEstate,
-  correctedFact,
-  correctionFor,
   focusView,
-  frameworkFacts,
-  frameworkGaps,
   nodeView,
   viewKey
-} from "./chunk-PAMPPUR6.js";
+} from "./chunk-JYMIB5XY.js";
 import {
   readServiceRequestExports,
+  readVendorSpec,
   readWorkItemExports
-} from "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-T6AIP7H5.js";
-import "./chunk-RZPYKDWS.js";
+} from "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-VUVGX5L2.js";
+import "./chunk-API5TOUB.js";
 import {
   baseClonePath,
   loadRepos,
   readChangeRepos
-} from "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
+} from "./chunk-XOL3GFW2.js";
 import {
   COMMON_SETTINGS,
   PROVIDER_SETTINGS,
   defaultKeyStore,
   looksLikeKey
-} from "./chunk-YEDDOYSC.js";
+} from "./chunk-PRW3HXM3.js";
 import {
   providerFactoryFor
-} from "./chunk-CNUKCS2T.js";
+} from "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
 import {
   ASSISTANTS,
   ChangeArtifact,
   DEFAULT_PORT,
   DEFAULT_RUNTIME,
+  DeclareError,
   DiagramLayout,
-  FACT_FIXED_FIELDS,
-  FactCorrection,
   KNOWLEDGE_KINDS,
   KNOWLEDGE_RECORD_KIND,
   LAYOUT_SCHEMA_VERSION,
   MANUAL_SYSTEMS,
+  ManifestEditError,
   QuestionError,
+  QuestionRole,
   QuestionState,
   RUN_SCHEMA_VERSION,
   RecordId,
   Runtime,
   SOURCE_KIND_SUGGESTIONS,
+  SPEC_HEADER_FILE,
+  TARGETS_STEP_ID,
+  TOPICS_STEP_ID,
   ViewKey,
+  acceptProposal,
+  addProfileSystem,
+  addRolesTeam,
+  answerByWords,
   answerQuestion,
   api_exports,
   catalogDirOf,
+  changedLines,
   changesDirOf,
   changesRelOf,
-  correctionLine,
+  copilotAcpOf,
+  currentSignal,
+  decideOf,
+  declareLink,
+  declaredOf,
+  diagramsRelOf,
+  eolOf,
   external_exports,
+  factIdPart,
   factsDirOf,
-  factsFileOf,
   factsRelOf,
   gateRoundLimit,
+  inEol,
   inputsDirOf,
   isAdopted,
+  joinConventions,
+  joinSharedMaps,
+  joinVendorOperations,
   knowledgeDirOf,
   knowledgeKindOf,
   knowledgeRelOf,
   layoutPath,
+  lfOnly,
   listQuestions,
   loadOrgPack,
+  manifestFiles,
   orgPackDirOf,
   pageStanding,
-  parseFacts,
-  parseFactsLines,
+  parseCorrections,
   proposalsDirOf,
   proposalsRelOf,
   readEstateJoins,
   readQuestion,
   readRepoSpec,
+  readSharedMaps,
   require_dist,
   runsDirOf,
   runsRelOf,
+  setManifestField,
+  specDirOf,
   specRelOf,
-  specRepos
-} from "./chunk-S2A7YC3Q.js";
+  specRepos,
+  undeclareLink
+} from "./chunk-PAINMSID.js";
 import {
+  FileChangedError,
   createLog,
-  writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+  writeFileAtomic,
+  writeFileIfUnchanged
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/ui-commands.js
 import { spawn } from "node:child_process";
-import { isAbsolute, join as join12, relative as relative3, sep as sep3 } from "node:path";
+import { isAbsolute, join as join14, relative as relative2, sep as sep2 } from "node:path";
 
 // packages/ui/dist-lib/index.js
 import { dirname, join } from "node:path";
@@ -361,8 +500,45 @@ function uiDistDir() {
 
 // 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";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, stat } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+var FACTS_REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+async function openTaskWorktree(root, change, task, gitHost) {
+  const p = await previewTaskRun(root, change, task, {
+    skipGitHost: true,
+    ...gitHost ? { gitHost } : {}
+  }).catch(() => void 0);
+  if (!p)
+    return void 0;
+  const text = await readFile(join2(changesDirOf(root), change, "repos.yaml"), "utf8").catch(() => "");
+  let has = false;
+  try {
+    const d = (0, import_yaml.parse)(text);
+    has = !!d?.repos?.some((r) => r.id === p.repo && r.worktree);
+  } catch {
+  }
+  if (has)
+    return void 0;
+  if (!existsSync(baseClonePath(root, p.repo))) {
+    const synced = await run((io) => workspaceSync(root, [p.repo], io));
+    if (synced.code !== 0)
+      return synced;
+    const opened = await run((io) => workspaceOpen(root, change, [p.repo], io));
+    return { ...opened, out: [...synced.out, ...opened.out] };
+  }
+  return run((io) => workspaceOpen(root, change, [p.repo], io));
+}
+var TASK_ERRORS = /* @__PURE__ */ new Set([
+  "SpecKitError",
+  "ChangeError",
+  "ChangeFileError",
+  "AdapterError",
+  "RuntimeConfigError",
+  "GitError",
+  "RuntimeError"
+]);
 async function run(f) {
   const out = [];
   const err = [];
@@ -413,6 +589,7 @@ async function changeDetail(root, id) {
   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 templateOnly = new Set(report.blockers.filter((b) => b.code === "unfilled-artifact").map((b) => b.artifact));
   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;
@@ -432,6 +609,8 @@ async function changeDetail(root, id) {
       artifact: a,
       path: `${changesRelOf(root)}/${id}/${files[0] ?? `${a}.md`}`,
       status: done ? "done" : at <= current ? "ready" : "blocked",
+      // Seventh UX walk (2.70.0): ready or blocked says what the phase allows, not that it is there.
+      written: files.length > 0 && !templateOnly.has(a),
       openFindings: findings.filter((f) => f.state === "open" && f.artifact.startsWith(a)).length
     });
   }
@@ -446,6 +625,8 @@ async function changeDetail(root, id) {
     openFindings: open,
     updatedAt: c.history.at(-1)?.at ?? c.createdAt,
     ...fast ? { fastPath: true } : {},
+    // Ninth UX walk (2.83.0): who owns each role, so the change page can name them.
+    owners: c.owners,
     artifacts,
     ...h ? {
       handoff: {
@@ -456,13 +637,82 @@ async function changeDetail(root, id) {
     } : {}
   };
 }
+async function applyFirstOf(root, files) {
+  const mtime = (p) => stat(p).then((s) => s.mtimeMs, () => void 0);
+  const out = [];
+  for (const f of files) {
+    const repo = /(?:^|\/)facts\/([^/]+)\.corrections\.jsonl$/.exec(f.path)?.[1] ?? await answeredMapQuestionRepo(root, f.path);
+    if (!repo || out.includes(repo))
+      continue;
+    const saved = await mtime(join2(root, ...f.path.split("/")));
+    if (saved === void 0)
+      continue;
+    const applied = await mtime(join2(specDirOf(root, repo), SPEC_HEADER_FILE)) ?? await mtime(join2(factsDirOf(root), `${repo}.verify.yaml`));
+    if (applied === void 0 || saved > applied)
+      out.push(repo);
+  }
+  return out;
+}
+async function answeredMapQuestionRepo(root, path) {
+  if (!/(?:^|\/)questions\/q-[^/]+\.yaml$/.test(path))
+    return void 0;
+  const q = await readFile(join2(root, ...path.split("/")), "utf8").then((t) => (0, import_yaml.parse)(t), () => void 0);
+  if (!q || q.state !== "answered" || typeof q.repo !== "string")
+    return void 0;
+  const of = /^atticus verify ([a-z0-9][a-z0-9._-]*) --write$/.exec(String(q.rerun ?? "").trim());
+  return of?.[1] === q.repo ? q.repo : void 0;
+}
+async function taskViews(root, change, prs) {
+  const dir = join2(changesDirOf(root), change);
+  let tasks = readChangeTasks(await readChangeFiles(dir));
+  const states = prs ? await Promise.all(tasks.map((t) => settleTaskPr(root, change, t.id, {
+    ...prs.gitHost ? { gitHost: prs.gitHost } : {},
+    ...prs.now ? { now: () => new Date(prs.now) } : {}
+  }).catch(() => ({})))) : [];
+  if (states.some((s) => s.ticked)) {
+    tasks = readChangeTasks(await readChangeFiles(dir));
+    prs?.onTick?.();
+  }
+  const waits = new Map((await readyTasksOf(root, change).catch(() => ({ tasks: [] }))).tasks.map((x) => [x.id, x]));
+  const out = [];
+  for (const [i, t] of tasks.entries()) {
+    const w = t.done ? void 0 : waits.get(t.id);
+    const tr = await readTaskRun(root, change, t.id).catch(() => void 0);
+    const run4 = tr ? tr.waiting ?? tr.runs[0] : void 0;
+    const prState = tr?.state === "pr-open" ? states[i]?.state : void 0;
+    out.push({
+      id: t.id,
+      repo: t.repo,
+      description: t.title,
+      done: t.done,
+      ...t.stories[0] ? { story: t.stories[0] } : {},
+      branch: `task/${change}/${t.id}`,
+      ...run4 ? { run: run4 } : {},
+      ...tr ? {
+        taskRun: {
+          state: tr.state,
+          level: tr.level,
+          branch: tr.branch,
+          ...tr.commit ? { commit: tr.commit } : {},
+          ...tr.pr ? { pr: { ...tr.pr, ...prState ? { state: prState } : {} } } : {},
+          ...tr.ticked ? { ticked: tr.ticked } : {},
+          ...tr.marked ? { marked: tr.marked } : {},
+          notes: tr.notes
+        }
+      } : {},
+      ...w?.waitsFor.length ? { waits: { tasks: w.waitsFor, sameRepo: w.sameRepo ?? [] } } : {}
+    });
+  }
+  return out;
+}
 async function runView(root, change, runId) {
   const dir = join2(runsDirOf(root), change, runId);
-  const text2 = await readFile(join2(dir, "run.json"), "utf8").catch(() => void 0);
-  if (!text2)
+  const text = await readFile(join2(dir, "run.json"), "utf8").catch(() => void 0);
+  if (!text)
     return void 0;
-  const r = JSON.parse(text2);
+  const r = JSON.parse(text);
   const manifest = await readFile(join2(dir, "context-manifest.json"), "utf8").catch(() => "");
+  const tr = await taskRunOfRun(root, change, runId).catch(() => void 0);
   return {
     schemaVersion: RUN_SCHEMA_VERSION,
     runId: r.runId,
@@ -479,7 +729,22 @@ async function runView(root, change, runId) {
     attempt: r.attempt ?? 1,
     ...r.stepClass ? { stepClass: r.stepClass } : {},
     ...r.model ? { model: r.model } : {},
-    promptPath: `${runsRelOf(root)}/${change}/${runId}/prompt.md`
+    ...r.batch ? { batch: r.batch } : {},
+    ...r.parts?.length ? { parts: await partStates(root, change, r.parts) } : {},
+    promptPath: `${runsRelOf(root)}/${change}/${runId}/prompt.md`,
+    ...tr ? {
+      taskRun: {
+        task: tr.task,
+        repo: tr.repo,
+        level: tr.level,
+        state: tr.state,
+        branch: tr.branch,
+        worktree: tr.worktree,
+        notes: tr.notes,
+        ...tr.commit ? { commit: tr.commit } : {},
+        ...tr.attempts.at(-1) ? { log: tr.attempts.at(-1).log } : {}
+      }
+    } : {}
   };
 }
 async function findRun(root, runId) {
@@ -492,23 +757,137 @@ async function findRun(root, runId) {
   }
   throw notFound(`There is no run ${runId}.`);
 }
-async function artifactPath(root, id, artifact) {
+async function artifactPath(root, id, artifact, o = {}) {
   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 (o.file) {
+    if (!files.includes(o.file))
+      throw notFound(`${o.file} isn't one of change ${id}'s ${artifact} files.`);
+    return o.file;
+  }
+  if (files.length === 0 && o.orNew && a.data !== "specs")
+    return a.data === "stories" ? "stories.md" : `${a.data}.md`;
   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 readyView = async (change) => {
+    const { deployOrderOf } = await import("./chunk-JKIGL3XQ.js");
+    const repoOrder = await deployOrderOf(root, change);
+    const prStates = /* @__PURE__ */ new Map();
+    for (const t of await taskViews(root, change, {
+      ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+      ...deps.now ? { now: deps.now } : {}
+    }))
+      if (t.taskRun?.pr?.state)
+        prStates.set(t.id, t.taskRun.pr.state);
+    const plan = await readyTasksOf(root, change, {
+      ...repoOrder ? { repoOrder } : {},
+      prStates
+    });
+    return api_exports.ReadyTasks.parse({ change, ...plan, ...repoOrder ? { repoOrder } : {} });
+  };
+  const doneBusy = /* @__PURE__ */ new Set();
   const changeDeps = {
     ...deps.gitHost ? { gitHost: deps.gitHost } : {},
     ...deps.now ? { now: deps.now } : {}
   };
-  return r.add("POST", "/api/changes", async ({ body }) => {
+  const localWhat = /* @__PURE__ */ new Map();
+  const asJob = (what, work) => {
+    const busy = ctx.jobs.runningOf("local");
+    if (busy)
+      throw conflict(`${localWhat.get(busy.id) ?? busy.progress.message} is running on this server (${busy.id}): wait for it to finish, then try again.`);
+    const job = ctx.jobs.start("local", async (c) => {
+      c.progress(0, 1, what);
+      const res = await work();
+      c.progress(1, 1, res.code === 0 ? "Done" : "Stopped");
+      ctx.events.publish({ type: "file.changed", path: "." });
+      const lines = [...res.out, ...res.err];
+      return { result: { code: res.code, lines }, errors: res.code === 0 ? [] : lines };
+    });
+    localWhat.set(job.id, what);
+    return { status: 202, body: { jobId: job.id } };
+  };
+  return r.add("POST", "/api/facts/{repo}/apply", async ({ params }) => {
+    const { verifyCommand } = await import("./chunk-T74WQQGS.js");
+    const repo = params.repo;
+    if (!FACTS_REPO.test(repo))
+      throw badRequest(`${JSON.stringify(repo)} isn't a repo name.`);
+    if (!(await loadRepos(root)).some((x) => x.id === repo))
+      throw notFound(`There is no repo ${repo} in this workspace.`);
+    return asJob(`Applying to ${repo}`, () => run((io) => verifyCommand(root, repo, { write: true, verbose: false, json: false }, io)));
+  }).add("GET", "/api/upgrade", async () => {
+    const { upgradeCheck } = await import("./chunk-AM6FP6JW.js");
+    const c = await upgradeCheck(root);
+    const body = {
+      atticus: c.atticus,
+      newer: c.newer,
+      ...c.stamp ? { stamp: c.stamp.atticus } : {},
+      pending: c.pending
+    };
+    return { status: 200, body };
+  }).add("POST", "/api/upgrade", async () => {
+    const { upgradeCheck, upgradeCommand } = await import("./chunk-AM6FP6JW.js");
+    const c = await upgradeCheck(root);
+    if (c.newer)
+      throw conflict(`This metarepo was upgraded by Atticus ${c.stamp.atticus}; this is ${c.atticus}. Install ${c.stamp.atticus} or later first.`);
+    if (!c.pending.length)
+      throw conflict(`Nothing to upgrade: up to date for Atticus ${c.atticus}.`);
+    return asJob("Upgrading the metarepo", () => run((io) => upgradeCommand(root, { by: user }, io)));
+  }).add("GET", "/api/propose", async ({ query }) => {
+    const { proposePlan, PROPOSE_SCOPES } = await import("./chunk-UZACEG2C.js");
+    const scope = query.get("scope") ?? "";
+    if (!PROPOSE_SCOPES.includes(scope))
+      throw refused({
+        code: 2,
+        out: [],
+        err: [`scope is one of ${PROPOSE_SCOPES.join(", ")}.`]
+      });
+    const plan = await proposePlan(root, scope, {
+      by: user
+    }).catch((e) => {
+      throw refused({
+        code: 1,
+        out: [],
+        err: [
+          `Atticus can't list what changed here: ${e.message.split("\n")[0]}. Propose for review needs the metarepo to be a Git repository with a remote.`
+        ]
+      });
+    });
+    return { status: 200, body: { ...plan, applyFirst: await applyFirstOf(root, plan.files) } };
+  }).add("POST", "/api/propose", async ({ body }) => {
+    const b = parseBody(api_exports.ProposeRequest, body);
+    const { proposeForReview } = await import("./chunk-UZACEG2C.js");
+    return asJob("Proposing for review", () => run((io) => proposeForReview(root, {
+      scope: b.scope,
+      by: user,
+      files: b.files,
+      ...b.title ? { title: b.title } : {},
+      ...b.branch ? { branch: b.branch } : {}
+    }, io)));
+  }).add("POST", "/api/propose/bring-in", async () => {
+    const { bringInMerged } = await import("./chunk-UZACEG2C.js");
+    return asJob("Bringing in what merged", () => run((io) => bringInMerged(root, io)));
+  }).add("POST", "/api/changes/{changeId}/conformance", async ({ params }) => {
+    await readChange(root, params.changeId);
+    const { changeConformCommand } = await import("./chunk-5CMPVC3N.js");
+    return asJob(`Checking ${params.changeId}'s code against its design`, () => run((io) => changeConformCommand(root, params.changeId, { findingsAnswer: true }, io)));
+  }).add("GET", "/api/change-types", async () => {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    return {
+      status: 200,
+      body: op.changeTypes.types.map((t) => ({
+        id: t.id,
+        name: t.name,
+        ...t.description ? { description: t.description } : {}
+      }))
+    };
+  }).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, {
@@ -530,7 +909,22 @@ function uiRoutes(r, ctx, deps = {}) {
   }).add("GET", "/api/changes/{changeId}", async ({ params }) => ({
     status: 200,
     body: await changeDetail(root, params.changeId)
-  })).add("GET", "/api/changes/{changeId}/status", async ({ params }) => {
+  })).add("PUT", "/api/changes/{changeId}/owners", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const b = parseBody(api_exports.ChangeOwnersRequest, body);
+    try {
+      await setChangeOwners(root, params.changeId, b.owners);
+    } catch (e) {
+      if (e instanceof ChangeOwnersError)
+        throw badRequest(e.message);
+      throw e;
+    }
+    ctx.events.publish({
+      type: "file.changed",
+      path: `${changesRelOf(root)}/${params.changeId}/change.yaml`
+    });
+    return { 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 {
@@ -554,10 +948,13 @@ function uiRoutes(r, ctx, deps = {}) {
         reasons: rep.reasons
       }
     };
-  }).add("GET", "/api/changes/{changeId}/artifacts/{artifact}", async ({ params }) => {
+  }).add("GET", "/api/changes/{changeId}/artifacts/{artifact}", async ({ params, query }) => {
     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");
+    const rel = await artifactPath(root, params.changeId, params.artifact, {
+      orNew: true,
+      file: query.get("file")
+    });
+    const content = await readFile(join2(changesDirOf(root), params.changeId, rel), "utf8").catch(() => "");
     return {
       status: 200,
       body: {
@@ -567,15 +964,27 @@ function uiRoutes(r, ctx, deps = {}) {
         sha256: sha(content)
       }
     };
-  }).add("PUT", "/api/changes/{changeId}/artifacts/{artifact}", async ({ params, body }) => {
+  }).add("PUT", "/api/changes/{changeId}/artifacts/{artifact}", async ({ params, body, query }) => {
     await readChange(root, params.changeId);
     const b = parseBody(api_exports.SaveArtifactRequest, body);
-    const rel = await artifactPath(root, params.changeId, params.artifact);
+    const rel = await artifactPath(root, params.changeId, params.artifact, {
+      orNew: true,
+      file: query.get("file")
+    });
     const file = join2(changesDirOf(root), params.changeId, rel);
-    const now = await readFile(file, "utf8");
+    const was = await readFile(file, "utf8").catch(() => void 0);
+    const now = was ?? "";
     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");
+    await mkdir(dirname2(file), { recursive: true });
+    await writeFileIfUnchanged(file, was, b.content);
+    const { recordPersonSave: recordPersonSave2 } = await import("./chunk-NTAVOWYD.js");
+    await recordPersonSave2(join2(changesDirOf(root), params.changeId), params.changeId, {
+      file: rel,
+      who: user,
+      at: (deps.now ? new Date(deps.now) : /* @__PURE__ */ new Date()).toISOString(),
+      content: b.content
+    }).catch(() => void 0);
     ctx.events.publish({
       type: "file.changed",
       path: `${changesRelOf(root)}/${params.changeId}/${rel}`
@@ -591,17 +1000,142 @@ function uiRoutes(r, ctx, deps = {}) {
     };
   }).add("GET", "/api/changes/{changeId}/tasks", async ({ params }) => {
     await readChange(root, params.changeId);
-    const files = await readChangeFiles(join2(changesDirOf(root), params.changeId));
+    const change = 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}`
-      }))
+      body: await taskViews(root, change, {
+        ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+        ...deps.now ? { now: deps.now } : {},
+        // Seventh UX walk: a task ticked because its PR merged changed tasks.md.
+        onTick: () => ctx.events.publish({
+          type: "file.changed",
+          path: `${changesRelOf(root)}/${change}/tasks.md`
+        })
+      })
+    };
+  }).add("POST", "/api/changes/{changeId}/tasks/{taskId}/done", async ({ params, body }) => {
+    await readChange(root, params.changeId);
+    const change = params.changeId;
+    const task = params.taskId;
+    const b = parseBody(api_exports.TaskDoneRequest, body);
+    if (!(await taskViews(root, change)).some((t) => t.id === task))
+      throw notFound(`Change ${change} has no task ${task}.`);
+    if (await setTaskDone(root, change, task, b.done))
+      ctx.events.publish({
+        type: "file.changed",
+        path: `${changesRelOf(root)}/${change}/tasks.md`
+      });
+    const tr = await readTaskRun(root, change, task).catch(() => void 0);
+    if (tr) {
+      tr.marked = {
+        done: b.done,
+        by: user,
+        at: (deps.now ? new Date(deps.now) : /* @__PURE__ */ new Date()).toISOString().replace(/\.000Z$/, "Z")
+      };
+      await saveTaskRun(root, tr);
+    }
+    return {
+      status: 200,
+      body: (await taskViews(root, change)).find((t) => t.id === task)
+    };
+  }).add("GET", "/api/changes/{changeId}/tasks/ready", async ({ params }) => {
+    await readChange(root, params.changeId);
+    return { status: 200, body: await readyView(params.changeId) };
+  }).add("POST", "/api/changes/{changeId}/tasks/run-ready", async ({ params, body }) => {
+    const change = params.changeId;
+    await readChange(root, change);
+    const b = parseBody(api_exports.RunReadyRequest, body);
+    const view3 = await readyView(change);
+    const tasks = b.tasks ? view3.ready.filter((t) => b.tasks.includes(t)) : view3.ready;
+    if (!tasks.length)
+      throw refused({
+        code: 1,
+        out: [],
+        err: [
+          b.tasks ? `None of ${b.tasks.join(", ")} is ready to run now: the Task board says why.` : `No task of ${change} is ready to run: each waits for the tasks before it, its PR, the assistant or a person.`
+        ]
+      });
+    const repoOf2 = new Map(view3.tasks.map((t) => [t.id, t.repo]));
+    const busy = ctx.jobs.runningOf("step");
+    if (busy)
+      throw conflict(`An AI step is running on this server (${busy.id}): wait for it to finish, or cancel it.`);
+    const job = ctx.jobs.start("step", async (c) => {
+      const r2 = await runReadyTasks(root, change, {
+        by: user,
+        only: tasks,
+        ...view3.repoOrder ? { repoOrder: view3.repoOrder } : {},
+        ...b.level ? { level: b.level } : {},
+        ...b.runtime ? { mode: b.runtime } : {},
+        // As Run with AI: runtime.yaml's level, lowered to the repo's cap, and at most draft.
+        levelFor: async (task) => {
+          const p = await previewTaskRun(root, change, task, {
+            skipGitHost: true,
+            ...deps.gitHost ? { gitHost: deps.gitHost } : {}
+          });
+          return p.level === "pr" ? "draft" : p.level;
+        },
+        // The task's repo gets its worktree when it has none yet, as Run with AI does.
+        before: async (task) => {
+          const opened = await openTaskWorktree(root, change, task, deps.gitHost);
+          return opened && opened.code !== 0 ? opened.err.join(" ") || opened.out.join(" ") || "Its worktree couldn't be opened." : void 0;
+        },
+        progress: (done, total, message) => c.progress(done, total, message),
+        cancelled: () => c.cancelled,
+        ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+        ...deps.taskRun?.git ? { git: deps.taskRun.git } : {},
+        ...deps.taskRun?.commands ? { commands: deps.taskRun.commands } : {}
+      });
+      for (const x of r2.ran)
+        ctx.events.publish({
+          type: "file.changed",
+          path: `${changesRelOf(root)}/${change}/tasks/${x.task}/task-run.yaml`
+        });
+      const ran = r2.ran.map((x) => "record" in x ? { task: x.task, repo: x.repo, state: x.record.state, branch: x.record.branch } : { task: x.task, repo: x.repo || (repoOf2.get(x.task) ?? ""), refused: x.refused });
+      const left = r2.stopped ? r2.planned.slice(r2.planned.indexOf(r2.stopped.task) + 1) : [];
+      return {
+        result: api_exports.RunReadyResult.parse({
+          ran,
+          ...r2.stopped ? { stopped: r2.stopped } : {},
+          left
+        })
+      };
+    });
+    return { status: 202, body: api_exports.RunReadyAccepted.parse({ jobId: job.id, tasks }) };
+  }).add("POST", "/api/changes/{changeId}/tasks/{taskId}/pr", async ({ params }) => {
+    await readChange(root, params.changeId);
+    const change = params.changeId;
+    const task = params.taskId;
+    if (!(await taskViews(root, change)).some((t) => t.id === task))
+      throw notFound(`Change ${change} has no task ${task}.`);
+    let raised;
+    try {
+      raised = await raiseTaskPr(root, change, task, {
+        approval: {
+          by: user,
+          at: (deps.now ? new Date(deps.now) : /* @__PURE__ */ new Date()).toISOString(),
+          ref: `task ${task} of ${change}: push and PR (the app's Raise the task's PR)`
+        },
+        ...deps.taskRun?.git ? { git: deps.taskRun.git } : {},
+        ...deps.gitHost ? { gitHost: deps.gitHost } : {}
+      });
+    } catch (e) {
+      if (e instanceof Error && (e.name === "TaskRunError" || TASK_ERRORS.has(e.name)))
+        throw refused({ code: 1, out: [], err: [e.message] });
+      throw e;
+    }
+    ctx.events.publish({
+      type: "file.changed",
+      path: `${changesRelOf(root)}/${change}/tasks/${task}/task-run.yaml`
+    });
+    if (raised.state !== "pr-open")
+      throw refused({
+        code: 1,
+        out: [],
+        err: [raised.notes.at(-1) ?? "The PR wasn't raised."]
+      });
+    return {
+      status: 201,
+      body: (await taskViews(root, change, { ...deps.gitHost ? { gitHost: deps.gitHost } : {} })).find((t) => t.id === task)
     };
   }).add("POST", "/api/changes/{changeId}/workspace", async ({ params, body }) => {
     await readChange(root, params.changeId);
@@ -617,41 +1151,69 @@ function uiRoutes(r, ctx, deps = {}) {
     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) };
+    return {
+      status: 201,
+      body: { ...await changeDetail(root, params.changeId), notes: res.out }
+    };
+  }).add("POST", "/api/changes/{changeId}/release-prs", async ({ params, body }) => {
+    const id = params.changeId;
+    await readChange(root, id);
+    parseBody(api_exports.ReleasePrsRequest, body);
+    const res = await run((io) => changeReleasePrs(root, id, { by: user, approve: true }, io, changeDeps));
+    ctx.events.publish({ type: "file.changed", path: `${id}/repos.yaml` });
+    if (res.code !== 0)
+      throw refused(res);
+    return { status: 201, body: api_exports.LinesView.parse({ lines: res.out }) };
   }).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);
+    const { appLines } = await import("./chunk-J2O4LFVI.js");
     return {
       status: 200,
       body: {
         ...await changeDetail(root, params.changeId),
-        lines: [...res.out, ...res.err]
+        lines: appLines([...res.out, ...res.err])
       }
     };
   }).add("GET", "/api/changes/{changeId}/inputs", async ({ params }) => {
     const c = await readChange(root, params.changeId);
-    const { readChangeInputs } = await import("./chunk-6JCPI55B.js");
+    const { readChangeInputs } = await import("./chunk-UDXWIPCB.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-Q4D5X7QB.js");
+    const { changePrototypes } = await import("./chunk-VYOCPTUB.js");
     return {
       status: 200,
       body: api_exports.ChangePrototypeList.parse(await changePrototypes(root, c.id))
     };
+  }).add("POST", "/api/changes/{changeId}/prototypes", async ({ params, body }) => {
+    const c = await readChange(root, params.changeId);
+    const b = parseBody(api_exports.ComparePrototypeRequest, body);
+    const { attachPrototype, changePrototypes } = await import("./chunk-VYOCPTUB.js");
+    const res = await run((io) => attachPrototype(root, c.id, b.repo, { by: user, ...deps.now ? { now: new Date(deps.now) } : {} }, io));
+    if (res.code !== 0)
+      throw refused(res);
+    ctx.events.publish({ type: "file.changed", path: `${changesRelOf(root)}/${c.id}/inputs` });
+    return {
+      status: 201,
+      body: api_exports.ComparePrototypeView.parse({
+        ...await changePrototypes(root, c.id),
+        lines: res.out
+      })
+    };
   }).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-NE2W3OO7.js");
+    const { attachFiles } = await import("./chunk-XQ3YZ4QW.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 ?? "", {
@@ -673,15 +1235,42 @@ function uiRoutes(r, ctx, deps = {}) {
     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")
+    if (b.task) {
+      let level = b.autonomy ? b.autonomy === "draft-and-pr" ? "pr" : b.autonomy === "plan-only" ? "plan" : "draft" : void 0;
+      if (level === "pr")
+        throw refused({
+          code: 1,
+          out: [],
+          err: [
+            "The pr level pushes the task branch and opens a PR, which needs the person's yes: start it from VS Code, IntelliJ or the command line (atticus task run <change> <task> --level pr --approve)."
+          ]
+        });
+      if (!level) {
+        try {
+          const p = await previewTaskRun(root, params.changeId, b.task, {
+            skipGitHost: true,
+            ...deps.gitHost ? { gitHost: deps.gitHost } : {}
+          });
+          level = p.level === "pr" ? "draft" : p.level;
+        } catch (e) {
+          if (e instanceof Error && e.name === "TaskRunError")
+            throw conflict(e.message);
+          if (e instanceof Error && TASK_ERRORS.has(e.name))
+            throw refused({ code: 1, out: [], err: [e.message] });
+          throw e;
+        }
+      }
+      const lv = level;
+      const opened = await openTaskWorktree(root, params.changeId, b.task, deps.gitHost);
+      if (opened && opened.code !== 0)
+        throw refused(opened);
+      res = await run((io) => taskRun(root, params.changeId, b.task, { mode: b.runtime, by: user, level: lv }, io, {
+        ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+        ...deps.taskRun?.git ? { git: deps.taskRun.git } : {}
+      }));
+      if (opened)
+        res = { ...res, out: [...opened.out, ...res.out] };
+    } 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));
@@ -732,32 +1321,110 @@ function uiRoutes(r, ctx, deps = {}) {
     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));
+    if (doneBusy.has(params.runId))
+      throw conflict(`Done for ${params.runId} is already running; wait for it to finish.`);
+    doneBusy.add(params.runId);
+    let res;
+    try {
+      res = await run((io) => runDone(root, params.runId, { by: user }, io, deps.taskRun));
+    } finally {
+      doneBusy.delete(params.runId);
+    }
     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] } };
+    const { resumeAfterDone, appLines } = await import("./chunk-J2O4LFVI.js");
+    if (res.code !== 0)
+      throw refused({ ...res, out: appLines(res.out), err: appLines(res.err) });
+    const stepRunner = deps.runStep ?? (async (args) => {
+      const { main } = await import("./chunk-7FHNFCHK.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 };
+    });
+    const resumed = await resumeAfterDone(root, stepRunner, after.change, after.runId).catch((e) => ({ lines: [e.message] }));
+    if (resumed)
+      ctx.events.publish({ type: "file.changed", path: changesRelOf(root) });
+    return {
+      status: 200,
+      body: {
+        ...after,
+        // When the app resumed the step, runDone's "run the step again with --resume" is done;
+        // sixth UX walk: what is left to do is said in the app's words.
+        lines: [
+          ...resumed ? appLines([...res.out, ...res.err].filter((l) => !/--resume run-/.test(l))) : [...res.out, ...res.err],
+          ...resumed?.lines ?? []
+        ],
+        ...resumed?.next ? { next: resumed.next } : {}
+      }
+    };
   }).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 owner = await findTaskRunOfRun(root, v.runId);
+    if (owner && owner.waiting !== v.runId)
+      throw conflict(taskRunNotWaiting(v.runId, owner));
     const file = join2(runsDirOf(root), v.change, v.runId, "run.json");
-    const rec = JSON.parse(await readFile(file, "utf8"));
+    const was = await readFile(file, "utf8");
+    const rec = JSON.parse(was);
     rec.state = "prepared";
     rec.attempt = (rec.attempt ?? 1) + 1;
     rec.errors = [];
-    await writeFile(file, JSON.stringify(rec, null, 2) + "\n");
+    await writeFileIfUnchanged(file, was, 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 here = await findRun(root, params.runId).catch(() => void 0);
+    if (!here) {
+      let ended;
+      try {
+        ended = await cancelTaskRunWait(root, params.runId, { by: user });
+      } catch (e) {
+        if (e instanceof Error && e.name === "TaskRunError")
+          throw conflict(e.message);
+        throw e;
+      }
+      if (!ended)
+        throw notFound(`There is no run ${params.runId}.`);
+      const at = (/* @__PURE__ */ new Date()).toISOString();
+      const body = {
+        schemaVersion: RUN_SCHEMA_VERSION,
+        runId: params.runId,
+        change: ended.change,
+        agent: "task-runner",
+        runtime: "hand-off",
+        state: "cancelled",
+        startedAt: ended.startedAt,
+        finishedAt: at,
+        contextManifestSha256: sha(""),
+        errors: [],
+        attempt: 1
+      };
+      ctx.events.publish({ type: "run.changed", runId: params.runId, state: "cancelled" });
+      return { status: 200, body };
+    }
     const v = await findRun(root, params.runId);
     if (["validated", "cancelled"].includes(v.state))
       throw conflict(`Run ${v.runId} is already ${v.state}.`);
+    if (doneBusy.has(v.runId))
+      throw conflict(`Done for ${v.runId} is running; wait for it to finish.`);
     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 cancelRun = async () => {
+      const was = await readFile(file, "utf8");
+      const rec = JSON.parse(was);
+      rec.state = "cancelled";
+      rec.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await writeFileIfUnchanged(file, was, JSON.stringify(rec, null, 2) + "\n");
+    };
+    try {
+      await cancelTaskRunWait(root, v.runId, { by: user, cancelRun });
+    } catch (e) {
+      if (e instanceof Error && e.name === "TaskRunError")
+        throw conflict(e.message);
+      throw e;
+    }
     const after = await findRun(root, params.runId);
     ctx.events.publish({ type: "run.changed", runId: after.runId, state: after.state });
     return { status: 200, body: after };
@@ -840,8 +1507,10 @@ function uiRoutes(r, ctx, deps = {}) {
 }
 
 // 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";
+var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash as createHash2 } from "node:crypto";
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { homedir } from "node:os";
 import { join as join3, resolve } from "node:path";
 async function run2(f) {
   const out = [];
@@ -862,11 +1531,11 @@ function parseBody2(schema, body) {
   return r.data;
 }
 function jsonOf(r) {
-  const text2 = r.out.join("\n").trim();
-  if (!text2.startsWith("{") && !text2.startsWith("["))
+  const text = r.out.join("\n").trim();
+  if (!text.startsWith("{") && !text.startsWith("["))
     return void 0;
   try {
-    return JSON.parse(text2);
+    return JSON.parse(text);
   } catch {
     return void 0;
   }
@@ -898,7 +1567,7 @@ async function latestFindings2(root, change) {
   }
   return out;
 }
-async function filesUnder(dir, prefix = "") {
+async function filesUnder2(dir, prefix = "") {
   const out = [];
   let entries;
   try {
@@ -909,9 +1578,9 @@ async function filesUnder(dir, prefix = "") {
   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));
+      out.push(...await filesUnder2(join3(dir, e.name), rel));
     else
-      out.push({ path: rel, bytes: (await stat(join3(dir, e.name))).size });
+      out.push({ path: rel, bytes: (await stat2(join3(dir, e.name))).size });
   }
   return out;
 }
@@ -971,6 +1640,8 @@ async function findStep(root, id, change) {
     throw notFound(`There is no step ${stepRef(id, change)}.`);
   return s;
 }
+var sha2 = (s) => createHash2("sha256").update(s).digest("hex");
+var snowText = (dir) => readFile2(join3(dir, "snow.md"), "utf8").catch(() => "");
 var SyncEntries = external_exports.object({
   requests: external_exports.array(external_exports.object({ key: external_exports.string(), id: external_exports.string() })).default([])
 });
@@ -979,9 +1650,13 @@ async function changeRequests(root, change, templates, steps) {
   const drafts = readSnowDrafts(await readChangeFiles(dir));
   if (drafts.length === 0)
     return [];
+  const snow = {
+    file: `${changesRelOf(root)}/${change}/snow.md`,
+    sha256: sha2(await snowText(dir))
+  };
   let synced = [];
   try {
-    synced = SyncEntries.parse((0, import_yaml.parse)(await readFile2(join3(dir, SYNC_FILE), "utf8"))).requests;
+    synced = SyncEntries.parse((0, import_yaml2.parse)(await readFile2(join3(dir, SYNC_FILE), "utf8"))).requests;
   } catch {
   }
   return drafts.map((d) => {
@@ -1001,7 +1676,8 @@ async function changeRequests(root, change, templates, steps) {
       record,
       approvers: t?.approvers ?? [],
       fields,
-      missing: fields.filter((f) => f.required && !f.value.trim()).map((f) => f.name)
+      missing: fields.filter((f) => f.required && !f.value.trim()).map((f) => f.name),
+      ...snow
     };
     const entry = t ? synced.find((e) => e.key === `${t.id}|${record}`) : void 0;
     if (!entry)
@@ -1052,6 +1728,23 @@ function uiRunRoutes(r, ctx, deps = {}) {
   const nowDate = deps.now ? () => new Date(deps.now) : void 0;
   const pack = () => loadOrgPack(orgPackDirOf(root));
   const rel = deps.now ? { now: () => new Date(deps.now) } : {};
+  const syncAfterStep = async (s) => {
+    if (s.system !== "git-host" || !s.change || s.state === "open")
+      return void 0;
+    const c = await changeStore(root).tryRead(s.change).catch(() => void 0);
+    const live = c && c.state !== "returned" ? liveHandoff(c) : void 0;
+    const steps = await fileStepStore(root).list({ change: s.change, system: "git-host" });
+    const open = s.action === "open-pull-request" ? s : steps.find((x) => x.action === "open-pull-request" && s.dependsOn.includes(x.id));
+    if (!live || !open || open.inputs.head !== live.branch)
+      return void 0;
+    const repo = typeof open.inputs.repo === "string" ? open.inputs.repo : void 0;
+    const res = await run2((io) => changeSync(root, s.change, { by: user, ...repo ? { repo } : {} }, io, {
+      ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+      ...deps.now ? { now: deps.now } : {}
+    }));
+    ctx.events.publish({ type: "file.changed", path: `${changesRelOf(root)}/${s.change}` });
+    return [...res.out, ...res.err];
+  };
   return r.add("GET", "/api/todo", async ({ query }) => {
     const change = strParam(query, "change");
     const op = await pack();
@@ -1126,7 +1819,8 @@ function uiRunRoutes(r, ctx, deps = {}) {
     }
     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 } };
+    const synced = await syncAfterStep(s);
+    return { status: 200, body: { ...s, lines: res.out, ...synced ? { synced } : {} } };
   }).add("GET", "/api/todo/{stepId}/run", async ({ params, query }) => {
     const s = await findStep(root, params.stepId, strParam(query, "change"));
     const op = await pack();
@@ -1199,12 +1893,44 @@ function uiRunRoutes(r, ctx, deps = {}) {
       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,
+  }).add("PUT", "/api/service-desk/{changeId}/fields", async ({ params, body }) => {
+    const c = await readChange2(root, params.changeId);
+    const b = parseBody2(api_exports.FillRequestFieldsRequest, body);
+    const dir = changeFolder(root, c.id);
+    const rel2 = `${changesRelOf(root)}/${c.id}/snow.md`;
+    const was = await readFile2(join3(dir, "snow.md"), "utf8").catch(() => void 0);
+    if (was === void 0)
+      throw notFound(`${c.id} has no snow.md: draft its requests first.`);
+    if (sha2(was) !== b.baseSha256)
+      throw conflict(`${rel2} changed since you opened it (another edit, or a person's): reload the page and fill the fields again.`);
+    let next;
+    try {
+      next = fillSnowFields(was, b.heading, b.values);
+    } catch (e) {
+      if (e instanceof SnowFillError)
+        throw new HttpError(422, "Atticus can't fill that", e.message);
+      throw e;
+    }
+    await writeFileIfUnchanged(join3(dir, "snow.md"), was, next);
+    ctx.events.publish({ type: "file.changed", path: rel2 });
+    const op = await pack();
+    const now = (await changeRequests(root, c.id, op.serviceRequests, [])).find((r2) => r2.heading === b.heading);
+    const names = Object.keys(b.values).join(", ");
+    return {
+      status: 200,
+      body: {
+        path: rel2,
+        sha256: sha2(next),
+        missing: now?.missing ?? [],
+        lines: [`Filled ${names} in ${rel2}.`]
+      }
+    };
+  }).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 } : {}
@@ -1293,7 +2019,7 @@ function uiRunRoutes(r, ctx, deps = {}) {
         } : {},
         conflicts,
         archive: { pass: archive.pass, blockers: archive.blockers, notes: archive.notes },
-        evidence: await filesUnder(changeFolder(root, id))
+        evidence: await filesUnder2(changeFolder(root, id))
       }
     };
   }).add("POST", "/api/release/{changeId}/archive", async ({ params, body }) => {
@@ -1470,7 +2196,7 @@ function uiRunRoutes(r, ctx, deps = {}) {
     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 view3 = lessons.map((l) => {
       const p = progress?.lessons[l.id];
       const done = p ? l.steps.filter((s) => p.steps[s.id]).length : 0;
       return {
@@ -1486,8 +2212,8 @@ function uiRunRoutes(r, ctx, deps = {}) {
     });
     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
+      lessons: view3.filter((v) => v.role === role).length,
+      done: view3.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;
@@ -1497,7 +2223,7 @@ function uiRunRoutes(r, ctx, deps = {}) {
       body: {
         sandbox,
         roles,
-        lessons: view2,
+        lessons: view3,
         ...cur ? {
           current: {
             lesson: cur.id,
@@ -1537,7 +2263,8 @@ function uiRunRoutes(r, ctx, deps = {}) {
     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 dir = b.dir.replace(/^~(?=$|[\\/])/, homedir());
+    const res = await run2((io) => sandboxCreate(resolve(root, dir), { json: true }, io, nowDate ? { now: nowDate() } : {}));
     const out = jsonOf(res);
     if (res.code !== 0 || !out)
       throw refused2(res);
@@ -1709,10 +2436,10 @@ function uiKnowRoutes(r, ctx, o = {}) {
   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)
+      const run4 = { at: Date.now(), checks: doctor(ctx.root) };
+      checked = run4;
+      run4.checks.catch(() => {
+        if (checked === run4)
           checked = void 0;
       });
     }
@@ -1720,7 +2447,7 @@ function uiKnowRoutes(r, ctx, o = {}) {
   };
   if (o.warm)
     void machine().catch(() => void 0);
-  const view2 = async (name, arg) => {
+  const view3 = async (name, arg) => {
     const build = VIEWS[name];
     if (!build)
       throw notFound(`There is no view ${name}.`);
@@ -1729,11 +2456,11 @@ function uiKnowRoutes(r, ctx, o = {}) {
     const args = build(arg);
     if (!args)
       throw badRequest(`The ${name} view needs an id: /api/view/${name}/<id>.`);
-    const { main } = await import("./chunk-A7UPUQFY.js");
+    const { main } = await import("./chunk-7FHNFCHK.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 text3 = out.join("\n").trim();
+    const text2 = out.join("\n").trim();
     if (code === 2) {
       const words = err.join("\n") || "The command refused the request.";
       if (scanFirst(words))
@@ -1742,18 +2469,24 @@ function uiKnowRoutes(r, ctx, o = {}) {
     }
     let body;
     try {
-      body = text3 ? JSON.parse(text3) : null;
+      body = text2 ? JSON.parse(text2) : null;
     } catch {
       body = void 0;
     }
+    if (body === null && code !== 0) {
+      const words = err.join("\n").trim() || "The command gave no answer.";
+      if (/^(There is no|No .+ (is|named) )/i.test(words))
+        throw notFound(words);
+      throw new HttpError(422, "Atticus can't show that yet", words, scanFirst(words) ? { notYet: true } : 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 text2 = async (args) => {
-    const { main } = await import("./chunk-A7UPUQFY.js");
+  const text = async (args) => {
+    const { main } = await import("./chunk-7FHNFCHK.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 });
@@ -1771,7 +2504,7 @@ function uiKnowRoutes(r, ctx, o = {}) {
       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-W3BQAZ3Q.js");
+    const { triageDecide } = await import("./chunk-ZKYRDV7A.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) });
@@ -1832,7 +2565,7 @@ function uiKnowRoutes(r, ctx, o = {}) {
       throw badRequest(`${focus} isn't an id.`);
     return {
       status: 200,
-      body: await text2(["diagram", "render", name, ...focus ? ["--focus", focus] : []])
+      body: await text(["diagram", "render", name, ...focus ? ["--focus", focus] : []])
     };
   }).add("GET", "/api/diagram/{view}/graph", async ({ params, query }) => {
     const name = params.view;
@@ -1841,7 +2574,7 @@ function uiKnowRoutes(r, ctx, o = {}) {
     const focus = query.get("focus") ?? void 0;
     if (focus !== void 0 && !ID.test(focus))
       throw badRequest(`${focus} isn't an id.`);
-    const r2 = await text2([
+    const r2 = await text([
       "diagram",
       "render",
       name,
@@ -1855,7 +2588,96 @@ function uiKnowRoutes(r, ctx, o = {}) {
       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));
+  }).add("GET", "/api/coverage", async () => {
+    const r2 = await view3("coverage");
+    const data = r2.body.data;
+    return { status: 200, body: data?.api ?? { areas: [], systems: [] } };
+  }).add("GET", "/api/view/{name}", ({ params }) => view3(params.name)).add("GET", "/api/view/{name}/{id}", ({ params }) => view3(params.name, params.id));
+}
+
+// packages/cli/dist/ui-api-initiatives.js
+var ID2 = /^[a-z0-9][a-z0-9._-]*$/;
+async function run3(f) {
+  const out = [];
+  const err = [];
+  const code = await f({ out: (l) => out.push(l), err: (l) => err.push(l) });
+  return { code, out, err };
+}
+function parseBody3(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 refused3(r) {
+  const detail = [...r.err, ...r.out].join("\n") || "Atticus refused.";
+  if (/^There is no (initiative|commitment) /m.test(detail))
+    return notFound(detail);
+  if (/already exists/.test(detail))
+    return conflict(detail);
+  return r.code === 2 ? badRequest(detail) : new HttpError(422, "Atticus refused", detail);
+}
+function uiInitiativeRoutes(r, ctx) {
+  const commands = () => import("./chunk-AE4P57KK.js");
+  const changed = () => ctx.events.publish({ type: "file.changed", path: "catalog/curated" });
+  return r.add("POST", "/api/initiatives", async ({ body }) => {
+    const b = parseBody3(api_exports.NewInitiativeRequest, body);
+    const { initiativeNew } = await commands();
+    const res = await run3((io) => initiativeNew(ctx.root, {
+      title: b.title,
+      journey: b.journey,
+      by: ctx.user,
+      ...b.id ? { id: b.id } : {},
+      ...b.release ? { release: b.release } : {},
+      ...b.epic ? { epic: b.epic } : {},
+      json: true
+    }, io));
+    if (res.code !== 0)
+      throw refused3(res);
+    const made = JSON.parse(res.out.join("\n"));
+    changed();
+    return {
+      status: 201,
+      body: {
+        initiative: made.initiative.id,
+        lines: [
+          `Started ${made.initiative.id} (${made.initiative.journey}). Wrote ${made.written}.`
+        ]
+      }
+    };
+  }).add("POST", "/api/initiatives/{initiativeId}/plan", async ({ params, body }) => {
+    const id = params.initiativeId;
+    if (!ID2.test(id))
+      throw badRequest(`${id} isn't an id.`);
+    const b = parseBody3(api_exports.InitiativePlanRequest, body);
+    const { initiativePlan } = await commands();
+    const res = await run3((io) => initiativePlan(ctx.root, id, {
+      by: ctx.user,
+      ...b.target ? { target: b.target } : {},
+      ...b.release ? { release: b.release } : {},
+      ...b.systems?.length ? { systems: b.systems } : {}
+    }, io));
+    if (res.code !== 0)
+      throw refused3(res);
+    changed();
+    return { status: 200, body: { initiative: id, lines: res.out } };
+  }).add("POST", "/api/commitments/{commitmentId}/status", async ({ params, body }) => {
+    const id = params.commitmentId;
+    if (!ID2.test(id))
+      throw badRequest(`${id} isn't an id.`);
+    const b = parseBody3(api_exports.CommitmentStatusRequest, body);
+    const c = (await readView(ctx.root)).get("Commitment", id);
+    if (!c)
+      throw notFound(`There is no commitment ${id}.`);
+    const { initiativeCommitment } = await commands();
+    const res = await run3((io) => initiativeCommitment(ctx.root, id, b.status, { by: ctx.user, ...b.note ? { note: b.note } : {} }, io));
+    if (res.code !== 0)
+      throw refused3(res);
+    changed();
+    return { status: 200, body: { initiative: c.initiative, lines: res.out } };
+  });
 }
 
 // packages/cli/dist/ui-api-questions.js
@@ -1865,8 +2687,82 @@ function uiQuestionRoutes(r, ctx, deps = {}) {
     const state = strParam(query, "state");
     if (state !== void 0 && !QuestionState.safeParse(state).success)
       throw badRequest("state is open, answered or retired.");
-    const body = await listQuestions(ctx.root, state ? { state } : {});
+    const mine = strParam(query, "mine");
+    if (mine !== void 0 && mine !== "true")
+      throw badRequest("mine is true, or left out.");
+    const change = strParam(query, "change");
+    if (change !== void 0 && !RecordId.safeParse(change).success)
+      throw badRequest("change is a change's id, or left out.");
+    const role = strParam(query, "role");
+    if (role !== void 0 && !QuestionRole.safeParse(role).success)
+      throw badRequest("role is product, architecture, analysis or delivery, or left out.");
+    const onFile = await listQuestions(ctx.root);
+    const every = { ...onFile, questions: onFile.questions.filter((q) => !q.finding) };
+    const { routeQuestions } = await import("./chunk-Z3QFH7YG.js");
+    const routedAll = await routeQuestions(ctx.root, every.questions, mine ? { mine: ctx.user } : {});
+    const { stageQuestions, roleWithStage, isChangeQuestion, countByRole, personsRoles } = await import("./chunk-KYZMRSPS.js");
+    const stages = await stageQuestions(ctx.root);
+    const roleOf = (q) => roleWithStage(q, stages);
+    for (const q of every.questions) {
+      const r2 = roleOf(q);
+      const a = routedAll.about[q.id];
+      if (r2 && a)
+        a.role = r2;
+    }
+    const base = change ? routedAll.questions.filter((q) => isChangeQuestion(q, change, { stages, restsOn: routedAll.about[q.id]?.restsOn })) : routedAll.questions;
+    const routed = {
+      ...routedAll,
+      questions: base.filter((q) => (!state || q.state === state) && (!role || roleOf(q) === role))
+    };
+    const listed = { problems: every.problems };
+    const n = (s) => base.filter((q) => q.state === s).length;
+    const body = {
+      counts: {
+        open: n("open"),
+        answered: n("answered"),
+        retired: n("retired"),
+        total: base.length,
+        byRepo: Object.fromEntries([...new Set(base.map((q) => q.repo))].sort().map((r2) => {
+          const of = base.filter((q) => q.repo === r2);
+          const k = (s) => of.filter((q) => q.state === s).length;
+          return [
+            r2,
+            {
+              open: k("open"),
+              answered: k("answered"),
+              retired: k("retired"),
+              total: of.length
+            }
+          ];
+        })),
+        byRole: countByRole(base, roleOf)
+      },
+      questions: routed.questions,
+      problems: [...listed.problems, ...routed.problems],
+      about: routed.about,
+      ...routed.me ? { me: routed.me } : {},
+      ...change ? { yourRoles: await personsRoles(ctx.root, change, ctx.user) } : {}
+    };
     return { status: 200, body };
+  }).add("GET", "/api/owner-questions", async () => {
+    const { ownerQuestions } = await import("./chunk-M4H2UG4R.js");
+    return { status: 200, body: await ownerQuestions(ctx.root, { now: now() }) };
+  }).add("POST", "/api/owner-questions/{id}/answer", async ({ params, body }) => {
+    const b = api_exports.OwnerAnswerRequest.safeParse(body ?? {});
+    if (!b.success || !b.data.answer.trim())
+      throw badRequest('Answer with { answer: "what the owner said" }.');
+    const { answerOwnerQuestion, OwnerQuestionError } = await import("./chunk-M4H2UG4R.js");
+    try {
+      const r2 = await answerOwnerQuestion(ctx.root, params.id, b.data.answer, {
+        by: ctx.user,
+        now: now()
+      });
+      return { status: 200, body: r2 };
+    } catch (e) {
+      if (e instanceof OwnerQuestionError)
+        throw e.code === "not-found" ? notFound(e.message) : badRequest(e.message);
+      throw e;
+    }
   }).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.`);
@@ -1874,11 +2770,19 @@ function uiQuestionRoutes(r, ctx, deps = {}) {
     if (!q)
       throw notFound(`There is no question ${params.id}.`);
     return { status: 200, body: q };
+  }).add("GET", "/api/questions/{id}/targets", async ({ params }) => {
+    const q = await readQuestion(ctx.root, params.id).catch(() => void 0);
+    if (!q)
+      throw notFound(`There is no question ${params.id}.`);
+    if (q.askedBy.step !== TARGETS_STEP_ID && q.askedBy.step !== TOPICS_STEP_ID)
+      throw new HttpError(422, "That question doesn't ask where a call goes or who owns a topic", `${q.id} isn't a targets or topics question, so it has no picker.`);
+    const { pickerOf } = await import("./chunk-IFFRGC3N.js");
+    return { status: 200, body: { picks: await pickerOf(ctx.root) } };
   }).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-6JUBZBMW.js");
+    const { evidenceExcerpts } = await import("./chunk-UFE36WJH.js");
     return {
       status: 200,
       body: {
@@ -1892,8 +2796,39 @@ function uiQuestionRoutes(r, ctx, deps = {}) {
         errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
       });
     try {
-      const r2 = await answerQuestion(ctx.root, params.id, {
-        ...b.data,
+      const { acceptProposal: acceptProposal2, target, addSystem, name, ...given } = b.data;
+      let writeSystem;
+      let system;
+      if (target) {
+        if (acceptProposal2 || given.option !== void 0 || given.text !== void 0)
+          throw badRequest("Give target alone, not with option, text or acceptProposal.");
+        const q0 = await readQuestion(ctx.root, params.id).catch(() => void 0);
+        if (!q0)
+          throw notFound(`There is no question ${params.id}.`);
+        const { targetAnswerOf, offerLine } = await import("./chunk-IFFRGC3N.js");
+        const t = await targetAnswerOf(ctx.root, q0, target, {
+          ...addSystem ? { addSystem } : {},
+          ...name ? { name } : {}
+        });
+        if ("problem" in t)
+          throw badRequest([t.problem, ...t.offer ? [offerLine(q0.id, target, t.offer)] : []].join(" "), t.offer ? { offer: t.offer } : void 0);
+        given.text = t.text;
+        writeSystem = t.write;
+      }
+      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,
+        // Review item 14: the profile is written only once the answer is accepted.
+        ...writeSystem ? {
+          beforeWrite: async () => {
+            system = await writeSystem();
+          }
+        } : {},
         by: ctx.user,
         at: now().toISOString()
       });
@@ -1902,7 +2837,8 @@ function uiQuestionRoutes(r, ctx, deps = {}) {
         body: {
           question: r2.question,
           rerun: r2.question.rerun,
-          ...r2.skill ? { skill: r2.skill } : {}
+          ...r2.skill ? { skill: r2.skill } : {},
+          ...system ? { system } : {}
         }
       };
     } catch (e) {
@@ -1940,15 +2876,15 @@ async function latestFindings3(root, change) {
 }
 var SEVERITY_ORDER = ["blocking", "gap", "risk", "idea"];
 var AT_RELEASE = /* @__PURE__ */ new Set(["release-ready", "released", "post-release-review"]);
-async function acrossRows(root, view2) {
+async function acrossRows(root, view3) {
   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(() => []) : [];
+  const op = view3 === "requests" ? await loadOrgPack(orgPackDirOf(root)) : void 0;
+  const steps = view3 === "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) {
+    switch (view3) {
       case "findings":
         for (const f of await latestFindings3(root, c.id))
           rows.push({
@@ -2035,9 +2971,9 @@ async function acrossRows(root, view2) {
       }
     }
   }
-  if (view2 === "findings")
+  if (view3 === "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")
+  if (view3 === "releases")
     rows.sort((a, b) => Number(b.atRelease) - Number(a.atRelease));
   return rows;
 }
@@ -2127,13 +3063,13 @@ async function hopsFromTargetFlows(dir, mappings, interfaces) {
 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))
+    const view3 = strParam(query, "view") ?? "";
+    if (!ACROSS_VIEWS.includes(view3))
       throw badRequest(`Say which view: ?view= one of ${ACROSS_VIEWS.join(", ")}.`);
-    const rows = await acrossRows(root, view2);
+    const rows = await acrossRows(root, view3);
     return {
       status: 200,
-      body: { view: view2, changes: (await openChanges3(root)).length, rows }
+      body: { view: view3, changes: (await openChanges3(root)).length, rows }
     };
   }).add("GET", "/api/changes/{changeId}/mappings", async ({ params }) => {
     try {
@@ -2146,8 +3082,9 @@ function uiAcrossRoutes(r, ctx) {
 }
 
 // packages/cli/dist/ui-api-graph.js
-var import_yaml2 = __toESM(require_dist(), 1);
-import { readFile as readFile3 } from "node:fs/promises";
+var import_yaml3 = __toESM(require_dist(), 1);
+import { readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
 import { join as join4 } from "node:path";
 var lensOf = (v, fallback) => {
   if (v === null)
@@ -2167,13 +3104,27 @@ var keyOf = (k) => {
     throw badRequest(`${k} isn't a view key. Use <lens>.<node>, e.g. architecture.estate.`);
   return k;
 };
+function vscodeFileLink(path, line) {
+  const posix = path.replace(/\\/g, "/");
+  const segs = (posix.startsWith("/") ? posix.slice(1) : posix).split("/").map((x) => /^[A-Za-z]:$/.test(x) ? x : encodeURIComponent(x));
+  return `vscode://file/${segs.join("/")}:${line}`;
+}
 function uiGraphRoutes(r, ctx) {
-  const estate = async () => {
+  const memoKey = `estate:${ctx.root}`;
+  ctx.events.listen((e) => {
+    if (e.type === "file.changed" && typeof e.path === "string" && /^(\.atticus[\\/])?catalog[\\/]/.test(e.path))
+      recheckNow(memoKey);
+  });
+  const estate = async () => memoByFiles(memoKey, () => filesUnder(catalogDirOf(ctx.root)), buildFromCatalog, {
+    recheckAfterMs: 1e3
+  });
+  const buildFromCatalog = 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);
   };
+  setTimeout(() => void estate().catch(() => void 0), 0).unref?.();
   const guard = (f) => {
     try {
       return f();
@@ -2183,11 +3134,13 @@ function uiGraphRoutes(r, ctx) {
       throw e;
     }
   };
-  const readLayout = async (view2) => {
+  const layoutRel = (view3) => isAdopted(ctx.root) ? `.atticus/${layoutPath(view3)}` : layoutPath(view3);
+  const viewsRel = diagramsRelOf(ctx.root) + "/views";
+  const readLayout = async (view3) => {
     try {
-      const f = DiagramLayout.safeParse((0, import_yaml2.parse)(await readFile3(join4(ctx.root, layoutPath(view2)), "utf8")));
+      const f = DiagramLayout.safeParse((0, import_yaml3.parse)(await readFile3(join4(ctx.root, layoutRel(view3)), "utf8")));
       if (!f.success)
-        throw new HttpError(422, "Atticus refused", `${layoutPath(view2)} isn't a layout file.`);
+        throw new HttpError(422, "Atticus refused", `${layoutRel(view3)} isn't a layout file.`);
       return f.data;
     } catch (e) {
       if (e.code === "ENOENT")
@@ -2211,46 +3164,100 @@ function uiGraphRoutes(r, ctx) {
     const lens = lensOf(query.get("lens"), "data");
     const est = await estate();
     return { status: 200, body: guard(() => focusView(est, id, { lens })) };
+  }).add("GET", "/api/graph/views", async () => {
+    const dir = join4(ctx.root, ...viewsRel.split("/"));
+    const names = (await readdir3(dir).catch(() => [])).filter((n) => n.endsWith(".yaml")).sort();
+    const views = [];
+    for (const n of names) {
+      const v = api_exports.SavedCanvasView.safeParse((0, import_yaml3.parse)(await readFile3(join4(dir, n), "utf8").catch(() => "")));
+      if (v.success)
+        views.push(v.data);
+    }
+    return {
+      status: 200,
+      body: { views, dir: viewsRel }
+    };
+  }).add("PUT", "/api/graph/views/{name}", async ({ params, body, query }) => {
+    const b = api_exports.SavedCanvasView.safeParse({ ...body, name: params.name });
+    if (!b.success)
+      throw badRequest("Name the view (lower case, digits and dashes) and give its lens and node.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const v = { ...b.data, by: ctx.user, at: (/* @__PURE__ */ new Date()).toISOString() };
+    const rel = `${viewsRel}/${v.name}.yaml`;
+    if (existsSync2(join4(ctx.root, rel)) && query.get("replace") !== "1")
+      throw conflict(`There is a view ${v.name} already (${rel}): pick another name, or replace it.`);
+    await writeFileAtomic(join4(ctx.root, rel), (0, import_yaml3.stringify)(v));
+    ctx.events.publish({ type: "file.changed", path: rel });
+    return { status: 200, body: v };
+  }).add("GET", "/api/code-link", async ({ query }) => {
+    const repo = query.get("repo") ?? "";
+    const at = query.get("at") ?? "";
+    const m = /^(.+):(\d+)$/.exec(at);
+    if (!/^[A-Za-z0-9._-]{1,200}$/.test(repo) || !m || m[1].includes(".."))
+      throw badRequest("Say repo=<repo> and at=<file>:<line>.");
+    const line = Number(m[2]);
+    if (line < 1)
+      throw badRequest("A line is 1 or more.");
+    const dir = await checkoutOf(ctx.root, repo).catch(() => void 0);
+    if (!dir || !existsSync2(dir))
+      return {
+        status: 200,
+        body: {
+          line,
+          missing: `There is no checkout of ${repo} here (atticus sync clones it into the workspace).`
+        }
+      };
+    const path = join4(dir, ...m[1].split("/"));
+    return {
+      status: 200,
+      body: {
+        path,
+        line,
+        vscode: vscodeFileLink(path, line),
+        idea: `idea://open?file=${encodeURIComponent(path)}&line=${line}`
+      }
+    };
   }).add("GET", "/api/graph/layout/{viewKey}", async ({ params }) => {
-    const view2 = keyOf(params.viewKey);
-    const f = await readLayout(view2);
+    const view3 = keyOf(params.viewKey);
+    const f = await readLayout(view3);
     return {
       status: 200,
-      body: { view: view2, saved: !!f, path: layoutPath(view2), positions: f?.positions ?? {} }
+      body: { view: view3, saved: !!f, path: layoutRel(view3), positions: f?.positions ?? {} }
     };
   }).add("PUT", "/api/graph/layout/{viewKey}", async ({ params, body }) => {
-    const view2 = keyOf(params.viewKey);
+    const view3 = 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 (view3 !== viewKey(lens, node) && view3 !== viewKey(lens, node, "focus"))
+      throw badRequest(`${view3} 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,
+      view: view3,
       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) });
+    await writeFileAtomic(join4(ctx.root, layoutRel(view3)), (0, import_yaml3.stringify)(file));
+    ctx.events.publish({ type: "file.changed", path: layoutRel(view3) });
     return {
       status: 200,
-      body: { view: view2, saved: true, path: layoutPath(view2), positions: file.positions }
+      body: { view: view3, saved: true, path: layoutRel(view3), positions: file.positions }
     };
   });
 }
 
 // packages/cli/dist/ui-api-specs.js
-import { stat as stat2 } from "node:fs/promises";
+import { stat as stat3 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 var idOf2 = (v, what) => {
   if (!RecordId.safeParse(v).success)
@@ -2357,7 +3364,7 @@ function uiSpecRoutes(r, ctx) {
   });
   const deltasOf = async (change) => {
     const dir = join5(changesDirOf(root), change);
-    if (!await stat2(join5(dir, "change.yaml")).catch(() => void 0))
+    if (!await stat3(join5(dir, "change.yaml")).catch(() => void 0))
       throw notFound(`There is no change ${change}.`);
     return readDeltas(dir);
   };
@@ -2381,7 +3388,7 @@ function uiSpecRoutes(r, ctx) {
   });
   r.add("GET", "/api/changes/{changeId}/conformance", async ({ params }) => {
     const change = idOf2(params.changeId, "change");
-    const { conformanceOf } = await import("./chunk-T6XQL73F.js");
+    const { conformanceOf } = await import("./chunk-FRHD22WM.js");
     const c = await conformanceOf(root, change);
     if (!c)
       throw notFound(`There is no change ${change}.`);
@@ -2394,6 +3401,14 @@ function uiSpecRoutes(r, ctx) {
       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-2D7PWSOK.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);
@@ -2422,8 +3437,8 @@ function uiSpecRoutes(r, ctx) {
 }
 
 // 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";
+var import_yaml4 = __toESM(require_dist(), 1);
+import { readFile as readFile4, stat as stat4 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 var STALE_DAYS = 14;
 var SLUG = /^[a-z0-9][a-z0-9-]*$/;
@@ -2493,7 +3508,7 @@ function candidateView(c) {
     keepAs: keepAs(r.kind)
   };
 }
-var exists = (p) => stat3(p).then(() => true, () => false);
+var exists = (p) => stat4(p).then(() => true, () => false);
 function capture() {
   const lines = [];
   const problems = [];
@@ -2583,8 +3598,8 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
     const op = await loadOrgPack(orgPackDirOf(root));
     const platforms = [];
     for (const { platform } of op.profiles) {
-      const text2 = await readFile4(join6(proposalsDirOf(root), "orgpack", `${platform}.yaml`), "utf8").catch(() => void 0);
-      const data = text2 === void 0 ? void 0 : (0, import_yaml3.parse)(text2);
+      const text = await readFile4(join6(proposalsDirOf(root), "orgpack", `${platform}.yaml`), "utf8").catch(() => void 0);
+      const data = text === void 0 ? void 0 : (0, import_yaml4.parse)(text);
       const proposals = Array.isArray(data?.proposals) ? data.proposals.flatMap((p) => {
         const x = OrgPackProposal.safeParse(p);
         return x.success ? [x.data] : [];
@@ -2592,7 +3607,7 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
       platforms.push({
         platform,
         file: `${proposalsRelOf(root)}/orgpack/${platform}.yaml`,
-        present: text2 !== void 0,
+        present: text !== void 0,
         ...typeof data?.at === "string" ? { at: data.at } : {},
         proposals,
         command: `atticus orgpack draft --platform ${platform}`
@@ -2615,8 +3630,8 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
       let snapshot;
       if (date) {
         const file = join6(knowledgeDirOf(root), "snapshots", w.id, date, SNAPSHOT_FILE);
-        const text2 = await readFile4(file, "utf8").catch(() => void 0);
-        const m = text2 === void 0 ? void 0 : SnapshotManifest.safeParse((0, import_yaml3.parse)(text2));
+        const text = await readFile4(file, "utf8").catch(() => void 0);
+        const m = text === void 0 ? void 0 : SnapshotManifest.safeParse((0, import_yaml4.parse)(text));
         if (m?.success)
           snapshot = {
             date,
@@ -2856,7 +3871,7 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
     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) => ({
+    const view3 = (n) => ({
       ...n,
       ...k?.reviews[n.item] ? { review: k.reviews[n.item] } : {}
     });
@@ -2865,7 +3880,7 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
       file: `${changesRelOf(root)}/${change}/${NEEDS_FILE}`,
       present: !!f,
       ...f ? { updatedAt: f.updatedAt } : {},
-      needs: (f?.needs ?? []).map(view2),
+      needs: (f?.needs ?? []).map(view3),
       considered: f?.considered ?? [],
       command: `atticus change needs ${change}`,
       slash: `/atticus-needs ${change}`
@@ -2930,7 +3945,8 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
     const result = {
       knowledge: await appliesView(change),
       file: before.file,
-      commit: `git add ${before.file} && git commit -m "${change}: the knowledge that applies"`
+      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 }) => {
@@ -2968,17 +3984,17 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
 // 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);
+var import_yaml5 = __toESM(require_dist(), 1);
 async function serverModel(root) {
   return (await configuredModel(root))?.type ?? null;
 }
 async function configuredModel(root) {
-  const text2 = await readFile5(join7(orgPackDirOf(root), "runtime.yaml"), "utf8").catch(() => void 0);
-  if (!text2)
+  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)(text2);
+    y = (0, import_yaml5.parse)(text);
   } catch {
     return null;
   }
@@ -2994,26 +4010,29 @@ async function configuredModel(root) {
 function uiModelRunRoutes(r, ctx, deps = {}) {
   const root = ctx.root;
   const runStep = deps.runStep ?? (async (args) => {
-    const { main } = await import("./chunk-A7UPUQFY.js");
+    const { main } = await import("./chunk-7FHNFCHK.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.`);
+  return r.add("POST", "/api/runs/handoff", async ({ body }) => {
+    const words = stepWords(body);
+    const { prepareStep } = await import("./chunk-J2O4LFVI.js");
+    const { code, prepared } = await prepareStep(root, runStep, words);
+    ctx.events.publish({ type: "file.changed", path: runsRelOf(root) });
+    if (!prepared.runId && code !== 0)
+      throw new HttpError(422, "The step wasn't prepared", prepared.lines.join("\n") || "The step prepared no run.");
+    return { status: 201, body: prepared };
+  }).add("POST", "/api/runs", async ({ body }) => {
+    const words = stepWords(body);
     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 busy = ctx.jobs.runningOf("step");
+    if (busy)
+      throw conflict(`An AI step is running on this server (${busy.id}): wait for it to finish, or cancel it.`);
     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));
@@ -3054,136 +4073,1054 @@ function uiModelRunRoutes(r, ctx, deps = {}) {
     return { status: 200, body: t };
   });
 }
+function stepWords(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 = withoutSource(words).find((a) => a.startsWith("-"));
+  if (option)
+    throw badRequest(`${option} would be read as an option; give the step's arguments only.`);
+  return words;
+}
+var SOURCE_STEPS = /* @__PURE__ */ new Set(["knowledge scan", "knowledge find"]);
+function withoutSource(words) {
+  if (!SOURCE_STEPS.has(`${words[0]} ${words[1]}`))
+    return words;
+  const at = words.indexOf("--source");
+  const value = words[at + 1];
+  if (at < 0 || !value || value.startsWith("-"))
+    return words;
+  return [...words.slice(0, at), ...words.slice(at + 2)];
+}
 
-// 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;
+// packages/cli/dist/ui-api-copilot-runs.js
+import { randomBytes } from "node:crypto";
+
+// packages/cli/dist/copilot-run.js
+var TAB_LINES = 5e3;
+var CopilotRun = class {
+  view;
+  current = "run";
+  constructor(o) {
+    this.view = {
+      runId: o.runId,
+      jobId: o.jobId,
+      kind: o.kind,
+      ...o.repos?.length ? { repos: o.repos } : {},
+      ...o.force ? { force: true } : {},
+      state: "running",
+      ...o.by ? { by: o.by } : {},
+      ...o.model ? { model: o.model } : {},
+      startedAt: o.startedAt,
+      progress: { repos: 0, repoIndex: 0, sessions: 0 },
+      totals: { kept: 0, rejected: 0, tokens: 0 },
+      tabs: [{ id: "run", title: "Run", state: "running", from: 0, lines: [] }]
     };
-    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 };
+  }
+  tab(id) {
+    return this.view.tabs.find((t) => t.id === id) ?? this.view.tabs[0];
+  }
+  push(id, lines) {
+    const t = this.tab(id);
+    const at = t.from + t.lines.length;
+    t.lines.push(...lines);
+    if (t.lines.length > TAB_LINES) {
+      const drop = t.lines.length - TAB_LINES;
+      t.lines.splice(0, drop);
+      t.from += drop;
+    }
+    return { tab: t.id, title: t.title, at, lines };
+  }
+  /** A line the run printed: into the session under way (or just ended, until the next repo). */
+  line(text) {
+    return this.push(this.current, [text]);
+  }
+  /** A step of the run: progress, and the tabs it opens or closes. Returns the lines it adds. */
+  event(e) {
+    const v = this.view;
+    const out = [];
+    switch (e.type) {
+      case "plan":
+        v.progress.repos = e.repos.length;
+        break;
+      case "repo":
+        v.progress.repoIndex = e.index;
+        v.progress.repos = e.total;
+        v.progress.repo = e.repo;
+        delete v.progress.session;
+        this.current = "run";
+        break;
+      case "session": {
+        const id = `s${v.progress.sessions + 1}`;
+        v.progress.sessions++;
+        const title = `${e.repo}, ${e.label}${e.attempt ? " (again)" : ""}`;
+        v.progress.session = title;
+        v.tabs.push({ id, title, repo: e.repo, state: "running", from: 0, lines: [] });
+        out.push(this.push("run", [`Session ${v.progress.sessions}: ${title}`]));
+        this.current = id;
+        break;
+      }
+      case "session.end": {
+        const t = v.tabs.findLast((x) => x.repo === e.repo && x.state === "running");
+        if (t) {
+          t.state = e.failed ? "failed" : "ended";
+          t.ended = e.failed ?? e.ended;
+          out.push(this.push("run", [`${t.title}: ended (${t.ended})`]));
+        }
+        if (e.tokens)
+          v.totals.tokens += e.tokens;
+        delete v.progress.session;
+        break;
+      }
+      case "verify":
+        v.totals.kept += e.kept;
+        v.totals.rejected += e.rejected;
+        if (this.current !== "run")
+          out.push(this.push("run", [
+            `${e.repo}: ${e.kept} kept, ${e.rejected} rejected, coverage ${Math.round(e.coverage * 100)}%, ${e.open} open`
+          ]));
+        break;
+    }
+    return out;
+  }
+  /** How it ended: done, stopped by a person, or failed with the error said. */
+  finish(state, at, message) {
+    const v = this.view;
+    v.state = state;
+    v.finishedAt = at;
+    if (message)
+      v.message = message;
+    for (const t of v.tabs)
+      if (t.state === "running") {
+        t.state = state === "failed" ? "failed" : "ended";
+        if (t.id !== "run")
+          t.ended ??= state;
+      }
+    this.current = "run";
+    return this.push("run", [
+      state === "done" ? "The run finished." : state === "stopped" ? "Stopped. The next run carries on from here." : `The run stopped: ${message ?? "an error"}`
+    ]);
+  }
+  /** The state without the lines, for the live event. */
+  summary() {
+    const { tabs: _tabs, ...rest } = this.view;
+    return structuredClone(rest);
+  }
+};
+
+// packages/cli/dist/ui-api-copilot-runs.js
+var defaultStarter = (root) => async (o, io, deps) => {
+  const { mapAllCommand } = await import("./chunk-YF5DZCPN.js");
+  return mapAllCommand(root, o, io, {
+    ...deps,
+    makeAcp: async () => (await import("./chunk-ZPDDEVQX.js")).acpStepRunner(root)
   });
+};
+var TAIL = 200;
+var NOT_ALLOWED = "runtime.yaml doesn't allow copilot-acp here (schemaVersion 3, copilot-acp in modes.allowed and copilot in assistants.allowed), so the app can't start Copilot itself. Read through Copilot Chat instead: atticus map --all in a terminal gives each part to paste.";
+async function allowedHere(root) {
+  try {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const c = copilotAcpOf(op.runtime);
+    return { allowed: copilotAcpAllowed(op), ...c.model ? { model: c.model } : {} };
+  } catch {
+    return { allowed: false };
+  }
 }
-
-// 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);
+var optionsOf = (b) => ({
+  mode: "copilot-acp",
+  ...b.kind === "stale" ? { stale: true } : {},
+  ...b.kind === "gaps" ? { gaps: true } : {},
+  ...b.repos?.length ? { repos: b.repos } : {},
+  ...b.force ? { force: true } : {},
+  resumeAs: "the next run (Map from the app, or atticus map --all)"
+});
+function uiCopilotRunRoutes(r, ctx, deps = {}) {
+  const start = deps.start ?? defaultStarter(ctx.root);
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const flushMs = deps.flushMs ?? 100;
+  let run4;
+  let allowed;
+  let seq = 0;
+  let starting = false;
+  const pending = /* @__PURE__ */ new Map();
+  let timer;
+  const flush = () => {
+    timer = void 0;
+    const r0 = run4;
+    if (!r0)
+      return;
+    for (const n of pending.values())
+      ctx.events.publish({ type: "copilot-run.lines", runId: r0.view.runId, ...n });
+    pending.clear();
   };
-  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;
+  const queue = (n) => {
+    const p = pending.get(n.tab);
+    if (p)
+      p.lines.push(...n.lines);
+    else
+      pending.set(n.tab, { ...n, lines: [...n.lines] });
+    timer ??= setTimeout(flush, flushMs);
+  };
+  const state = () => {
+    if (run4)
+      ctx.events.publish({ type: "copilot-run.state", run: run4.summary() });
+  };
+  return r.add("GET", "/api/copilot-runs/current", async ({ query }) => {
+    if (!allowed || Date.now() - allowed.at > 1e4)
+      allowed = { at: Date.now(), v: await allowedHere(ctx.root) };
+    const a = allowed.v;
+    const tail = Math.min(Math.max(Number(query.get("tail") ?? TAIL) || TAIL, 0), TAB_LINES);
+    const view3 = run4 ? {
+      ...run4.summary(),
+      tabs: run4.view.tabs.map((t) => {
+        const keep = tail ? t.lines.slice(-tail) : t.lines;
+        return { ...t, from: t.from + t.lines.length - keep.length, lines: [...keep] };
+      })
+    } : null;
     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()
+        run: view3,
+        allowed: a.allowed,
+        ...a.allowed ? {} : { why: NOT_ALLOWED },
+        ...a.model ? { model: a.model } : {}
       }
     };
-  }).add("PUT", "/api/settings/ai", async ({ body }) => {
-    const b = body ?? {};
-    const text2 = existsSync(file()) ? await readFile6(file(), "utf8") : void 0;
-    const raw = text2 !== void 0 ? (0, import_yaml5.parse)(text2) ?? {} : 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;
+  }).add("POST", "/api/copilot-runs", async ({ body }) => {
+    const b = api_exports.StartCopilotRunRequest.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 }))
+      });
+    if (b.data.kind === "repos" && !b.data.repos?.length)
+      throw badRequest("Name the repos to read (repos), or pick stale, gaps or all.");
+    if (run4?.view.state === "running")
+      throw conflict(`A Copilot run is under way (${run4.view.runId}, started ${run4.view.startedAt}): stop it, or wait for it to finish.`);
+    if (starting)
+      throw conflict("A Copilot run is starting: wait for it, then stop it if need be.");
+    const busy = ctx.jobs.runningOf("step");
+    if (busy?.state === "running")
+      throw conflict(`An AI step is running on this server (${busy.id}): wait for it to finish.`);
+    starting = true;
+    let a;
+    try {
+      a = await allowedHere(ctx.root);
+    } finally {
+      starting = false;
     }
-    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 = (text2 ?? "").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: {
+    if (!a.allowed)
+      throw conflict(NOT_ALLOWED);
+    if (ctx.jobs.runningOf("step")?.state === "running")
+      throw conflict("An AI step started on this server meanwhile: wait for it to finish.");
+    const runId = `copilot-run-${now().getTime().toString(36)}-${randomBytes(3).toString("hex")}-${++seq}`;
+    const me = new CopilotRun({
+      runId,
+      jobId: "",
+      kind: b.data.kind,
+      ...b.data.repos ? { repos: b.data.repos } : {},
+      ...b.data.force ? { force: true } : {},
+      ...ctx.user ? { by: ctx.user } : {},
+      ...a.model ? { model: a.model } : {},
+      startedAt: now().toISOString()
+    });
+    run4 = me;
+    let lastErr;
+    const job = ctx.jobs.start("step", async (c) => {
+      const io = {
+        out: (l) => queue(me.line(l)),
+        err: (l) => {
+          lastErr = l;
+          queue(me.line(l));
+        }
+      };
+      const onEvent = (e) => {
+        for (const n of me.event(e))
+          queue(n);
+        const p = me.view.progress;
+        c.progress(p.repoIndex, p.repos, p.session ?? p.repo ?? "Planning");
+        state();
+      };
+      const signal = currentSignal();
+      let code;
+      try {
+        code = await start(optionsOf(b.data), io, {
+          ...signal ? { signal } : {},
+          onEvent
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        queue(me.finish(signal?.aborted ? "stopped" : "failed", now().toISOString(), msg));
+        flush();
+        state();
+        ctx.events.publish({ type: "file.changed", path: "facts" });
+        return { errors: [msg] };
+      }
+      const stopped = signal?.aborted === true;
+      queue(me.finish(stopped ? "stopped" : code === 0 ? "done" : "failed", now().toISOString(), stopped || code === 0 ? void 0 : lastErr ?? `atticus map --all ended with ${code}`));
+      flush();
+      state();
+      ctx.events.publish({ type: "file.changed", path: "facts" });
+      return { result: { code, runId } };
+    });
+    me.view.jobId = job.id;
+    state();
+    return { status: 202, body: structuredClone(me.view) };
+  }).add("GET", "/api/copilot-runs/{runId}/tabs/{tab}", async ({ params, query }) => {
+    if (!run4 || run4.view.runId !== params.runId)
+      throw notFound(`There is no run ${params.runId}.`);
+    const t = run4.view.tabs.find((x) => x.id === params.tab);
+    if (!t)
+      throw notFound(`${params.runId} has no tab ${params.tab}.`);
+    const from = Math.max(Number(query.get("from") ?? 0) || 0, t.from);
+    return {
+      status: 200,
+      body: { id: t.id, title: t.title, from, lines: t.lines.slice(from - t.from) }
+    };
+  }).add("POST", "/api/copilot-runs/{runId}/stop", async ({ params }) => {
+    if (!run4 || run4.view.runId !== params.runId)
+      throw notFound(`There is no run ${params.runId}.`);
+    if (run4.view.state !== "running")
+      throw conflict(`${params.runId} has already ${run4.view.state === "done" ? "finished" : run4.view.state}.`);
+    ctx.jobs.cancel(run4.view.jobId);
+    queue(run4.line("Stopping: the session under way is cancelled..."));
+    return { status: 200, body: structuredClone(run4.view) };
+  });
+}
+
+// packages/cli/dist/ui-api-link-match.js
+var keyOf2 = (from, to) => `${from}\0${to.repo ?? ""}\0${to.system ?? ""}`;
+function uiLinkMatchRoutes(r, ctx, deps = {}) {
+  const running = /* @__PURE__ */ new Map();
+  return r.add("GET", "/api/links/match", async ({ query }) => {
+    const { from, to } = boxesOf(query);
+    const { view: view3 } = await candidatesOf(ctx.root, from, to);
+    const run4 = running.get(keyOf2(from, to));
+    const job = run4 ? ctx.jobs.get(run4.jobId) : void 0;
+    if (run4 && job?.state === "running") {
+      const files = await readMatch(ctx.root, view3);
+      return {
+        status: 200,
+        body: {
+          ...files,
+          state: "running",
+          jobId: run4.jobId,
+          proposals: [],
+          none: [],
+          rejected: []
+        }
+      };
+    }
+    const m = await readMatch(ctx.root, view3);
+    if (run4?.error && m.state === "handoff") {
+      m.state = "failed";
+      m.error = run4.error;
+    }
+    return { status: 200, body: m };
+  }).add("POST", "/api/links/match/done", async ({ body }) => {
+    const b = api_exports.MatchLinksRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say both boxes: { from: <repo>, to: { repo } | { system } }.");
+    const { from, to } = b.data;
+    const { view: view3, facts } = await candidatesOf(ctx.root, from, to);
+    const run4 = running.get(keyOf2(from, to));
+    if (run4 && ctx.jobs.get(run4.jobId)?.state === "running")
+      throw conflict(`A match of ${from} with ${view3.toName} is under way: wait for it.`);
+    const m = await matchDone(ctx.root, { view: view3, facts });
+    if (m.state === "handoff" || m.state === "idle")
+      throw conflict(m.error ?? `No answer is written yet for ${from} and ${view3.toName}.`);
+    if (m.decided?.batch) {
+      ctx.events.publish({ type: "file.changed", path: `facts/${from}.corrections.jsonl` });
+      ctx.events.publish({ type: "file.changed", path: "decisions/" });
+    }
+    return { status: 200, body: m };
+  }).add("POST", "/api/links/match", async ({ body }) => {
+    const b = api_exports.MatchLinksRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say both boxes: { from: <repo>, to: { repo } | { system } }.");
+    const { from, to } = b.data;
+    const { view: view3, facts } = await candidatesOf(ctx.root, from, to);
+    if (!view3.calls.some((c) => c.status !== "paired"))
+      throw conflict(`${from} has no loose call to match with ${view3.toName}.`);
+    if (!view3.apis.length)
+      throw conflict(`${view3.toName} has no API on record${view3.noApis ? `: ${view3.noApis.command}` : ""}.`);
+    const key = keyOf2(from, to);
+    const op = await loadOrgPack(orgPackDirOf(ctx.root));
+    const had = running.get(key);
+    if (had && ctx.jobs.get(had.jobId)?.state === "running")
+      throw conflict(`A match of ${from} with ${view3.toName} is under way: wait for it.`);
+    const busy = ctx.jobs.runningOf("step");
+    if (busy?.state === "running")
+      throw conflict(`An AI step is running on this server (${busy.id}): wait for it to finish.`);
+    if (!copilotAcpAllowed(op) && !deps.runner) {
+      const m = await runMatch(ctx.root, { view: view3, quotes: quotesOf(facts), mode: "hand-off" });
+      return { status: 202, body: m };
+    }
+    let done;
+    const job = ctx.jobs.start("step", async (c) => {
+      c.progress(0, 1, `Matching ${from} with ${view3.toName}`);
+      const signal = currentSignal();
+      try {
+        done = await runMatch(ctx.root, {
+          view: view3,
+          quotes: quotesOf(facts),
+          facts,
+          mode: "copilot-acp",
+          ...deps.runner ? { runner: deps.runner } : {},
+          ...signal ? { signal } : {},
+          onProgress: (line) => c.progress(0, 1, line.slice(0, 200))
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const me2 = running.get(key);
+        if (me2)
+          me2.error = msg;
+        return { errors: [msg] };
+      }
+      const me = running.get(key);
+      if (me && done.error)
+        me.error = done.error;
+      return done.state === "failed" ? { errors: [done.error ?? "The session ended without an answer."] } : { result: { state: done.state } };
+    });
+    running.set(key, { jobId: job.id });
+    const files = await readMatch(ctx.root, view3);
+    return {
+      status: 202,
+      body: {
+        ...files,
+        state: "running",
+        jobId: job.id,
+        proposals: [],
+        none: [],
+        rejected: []
+      }
+    };
+  });
+}
+
+// packages/cli/dist/ui-api-decisions.js
+var BATCH = /^b-\d{8}-\d{6}-[0-9a-f]{6}$/;
+function fail(e) {
+  if (e instanceof DecideError) {
+    if (e.code === "not-found")
+      throw notFound(e.message);
+    if (e.code === "conflict")
+      throw conflict(e.message);
+    if (e.code === "refused")
+      throw new HttpError(422, "Atticus can't do that", e.message);
+    throw badRequest(e.message);
+  }
+  throw e;
+}
+function uiDecisionRoutes(r, ctx, deps = {}) {
+  const now = () => deps.now?.() ?? /* @__PURE__ */ new Date();
+  return r.add("GET", "/api/decisions", async () => ({
+    status: 200,
+    body: await decisionsView(ctx.root)
+  })).add("POST", "/api/decisions/correct", async ({ body }) => {
+    const b = api_exports.CorrectDecisionRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say the item and the right answer: { item, option } for a question, { item, api, repo } or { item, none: true } for a pairing.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    let out;
+    try {
+      out = await correctDecision(ctx.root, b.data, { by: ctx.user, now: now() });
+    } catch (e) {
+      fail(e);
+    }
+    if (out.written)
+      for (const path of out.files)
+        ctx.events.publish({ type: "file.changed", path });
+    return { status: 200, body: out };
+  }).add("GET", "/api/propose-answers", async () => {
+    const { openDecideRun, PROPOSE_CHANGE } = await import("./chunk-EFCQSMXB.js");
+    const run4 = await openDecideRun(ctx.root, PROPOSE_CHANGE);
+    const body = run4 ? {
+      state: "waiting",
+      run: run4.runId,
+      line: "/atticus-propose",
+      prompt: `${runsRelOf(ctx.root)}/${PROPOSE_CHANGE}/${run4.runId}/prompt.md`,
+      done: `atticus handoff done ${run4.runId}`
+    } : { state: "none", line: "/atticus-propose" };
+    return { status: 200, body };
+  }).add("POST", "/api/propose-answers", async () => {
+    const op = await loadOrgPack(orgPackDirOf(ctx.root));
+    if (op.runtime.ai === "off")
+      throw conflict("runtime.yaml turns AI off here (ai: off): answer the questions yourself.");
+    const { startProposeHandoff } = await import("./chunk-ZPDDEVQX.js");
+    const h = await startProposeHandoff(ctx.root, { now: now() });
+    const body = {
+      state: "waiting",
+      run: h.runId,
+      line: h.line,
+      prompt: h.promptRel,
+      done: h.done
+    };
+    return { status: 201, body };
+  }).add("POST", "/api/decisions/batches/{batchId}/undo", async ({ params }) => {
+    const id = params.batchId ?? "";
+    if (!BATCH.test(id))
+      throw notFound(`There is no batch ${JSON.stringify(id)}.`);
+    let out;
+    try {
+      out = await undoBatch(ctx.root, id, { by: ctx.user, now: now() });
+    } catch (e) {
+      fail(e);
+    }
+    for (const path of out.files)
+      ctx.events.publish({ type: "file.changed", path });
+    return { status: 200, body: out };
+  });
+}
+
+// packages/cli/dist/ui-api-sketch.js
+import { createHash as createHash3 } from "node:crypto";
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+var CHANGE = /^[a-z0-9][a-z0-9._-]{0,199}$/;
+var drawnOf = (deltas) => drawnStrokes(deltas);
+function uiSketchRoutes(r, ctx) {
+  const root = ctx.root;
+  const changeOf = (v) => {
+    if (!CHANGE.test(v))
+      throw badRequest(`${v} isn't a change id.`);
+    return v;
+  };
+  const commitOf = (change) => `git add ${changesRelOf(root)}/${change}
+git commit -m "${safeMessage(`${change}: drawn on the canvas`)}"`;
+  return r.add("GET", "/api/changes/{changeId}/sketch", async ({ params }) => {
+    const change = changeOf(params.changeId);
+    const m = await changeMapOf(root, change);
+    if (!m)
+      throw notFound(`There is no change ${change}.`);
+    const dir = join8(changesDirOf(root), change);
+    const { deltas } = await readDeltas(dir);
+    return {
+      status: 200,
+      body: {
+        written: false,
+        files: [],
+        map: changeMapBody(change, m),
+        drawn: drawnOf(deltas),
+        commit: commitOf(change),
+        fingerprint: await sketchFingerprint(dir)
+      }
+    };
+  }).add("POST", "/api/changes/{changeId}/sketch", async ({ params, body }) => {
+    const change = changeOf(params.changeId);
+    const b = api_exports.SketchStrokeRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say the stroke: { stroke: { kind, ... }, preview? }.");
+    const s = Stroke.safeParse(b.data.stroke);
+    if (!s.success)
+      throw badRequest("The stroke isn't one Atticus draws.", {
+        errors: s.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const c = await changeStore(root).read(change).catch(() => void 0);
+    if (!c)
+      throw notFound(`There is no change ${change}.`);
+    const dir = changeFolder(root, change);
+    const t = await targetFlowsOf(root, change);
+    if (!t)
+      throw notFound(`There is no change ${change}.`);
+    const estate = await loadEstate(root, t.records);
+    const by = ctx.user ?? "a person";
+    return withFileLock(join8(dir, TARGET_DIR), async () => {
+      const fingerprint = await sketchFingerprint(dir);
+      const { deltas, problems } = await readDeltas(dir);
+      const answer = (extra) => ({
+        written: false,
+        files: [],
+        drawn: drawnOf(deltas),
+        commit: commitOf(change),
+        fingerprint,
+        ...extra
+      });
+      if (problems.length)
+        return {
+          status: 200,
+          body: answer({
+            problem: `A target flow of ${change} doesn't read, so nothing is drawn until it is fixed: ${problems[0]}`
+          })
+        };
+      const strokeId = createHash3("sha256").update(fingerprint).update(JSON.stringify(s.data)).digest("hex").slice(0, 8);
+      const res = applyStroke(deltas, s.data, estate, by, strokeId);
+      if (res.problem)
+        return {
+          status: 200,
+          body: answer({ problem: res.problem, ...res.pick ? { pick: res.pick } : {} })
+        };
+      const plan = await planSketchWrite(dir, res.deltas, res.changed, estate, by);
+      const files = (await Promise.all(plan.map(async (f) => ({
+        file: `${changesRelOf(root)}/${change}/${f.file}`,
+        changes: changedLines(lfOnly(await readFile6(join8(dir, ...f.file.split("/")), "utf8").catch(() => "")), lfOnly(f.now ?? ""))
+      })))).filter((f) => f.changes.length);
+      if (b.data.preview)
+        return { status: 200, body: answer({ files, drawn: drawnOf(res.deltas) }) };
+      if (b.data.expect !== void 0 && b.data.expect !== fingerprint)
+        throw conflict(`${change}'s target flows changed since the preview: look again, then draw the stroke again.`);
+      await writeSketch(dir, plan);
+      for (const f of files)
+        ctx.events.publish({ type: "file.changed", path: f.file });
+      const m = await changeMapOf(root, change);
+      return {
+        status: 200,
+        body: answer({
+          written: true,
+          files,
+          ...m ? { map: changeMapBody(change, m) } : {},
+          drawn: drawnOf(res.deltas),
+          fingerprint: await sketchFingerprint(dir)
+        })
+      };
+    });
+  });
+}
+
+// packages/cli/dist/ui-api-owner.js
+var REPO = /^[A-Za-z0-9._-]{1,200}$/;
+var TEAM = /^[a-z0-9][a-z0-9-]{0,62}$/;
+function uiOwnerRoutes(r, ctx) {
+  const options = async (repo) => {
+    if (!REPO.test(repo))
+      throw badRequest(`${JSON.stringify(repo)} isn't a repo name.`);
+    const op = await loadOrgPack(orgPackDirOf(ctx.root));
+    const entry = estateRepos(op).find((x) => x.id === repo);
+    if (!entry)
+      throw notFound(`No repo of the manifest is ${repo}.`);
+    const teams = (op.roles?.teams ?? []).map((t) => ({ id: t.id, name: t.name ?? t.id }));
+    const seen = /* @__PURE__ */ new Set();
+    const systems = op.profiles.flatMap((p) => p.profile?.systems ?? []).filter((s) => !seen.has(s.id) && !!seen.add(s.id)).map((s) => ({ id: s.id, name: s.name || s.id })).sort((a, b) => a.id < b.id ? -1 : 1);
+    return { entry, teams, systems };
+  };
+  return r.add("GET", "/api/repos/{repo}/owner", async ({ params }) => {
+    const repo = params.repo;
+    const o = await options(repo);
+    const file = (await manifestFiles(ctx.root)).find((f) => f.platform === o.entry.platform);
+    return {
+      status: 200,
+      body: {
+        repo,
+        owner: o.entry.owner,
+        ...o.entry.system ? { system: o.entry.system } : {},
+        file: file?.rel ?? "org-pack/profiles",
+        teams: o.teams,
+        systems: o.systems
+      }
+    };
+  }).add("PUT", "/api/repos/{repo}/owner", async ({ params, body }) => {
+    const repo = params.repo;
+    const b = api_exports.SetRepoOwnerRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say the owner, the system, or a team to add: { owner, system, addTeam }.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const o = await options(repo);
+    const { addTeam, preview, system } = b.data;
+    let owner = b.data.owner;
+    if (addTeam) {
+      if (!TEAM.test(addTeam.id))
+        throw badRequest(`${addTeam.id} isn't a team id: lower case, digits and dashes, e.g. team-ledger.`);
+      if (o.teams.some((t) => t.id === addTeam.id))
+        throw badRequest(`${addTeam.id} is a team already: pick it as the owner.`);
+      owner = addTeam.id;
+    } else if (owner && !o.teams.some((t) => t.id === owner) && (o.teams.length || !TEAM.test(owner)))
+      throw badRequest(`No team in roles.yaml is ${owner}: pick one, or add it as a new team.`);
+    if (system && !o.systems.some((s) => s.id === system))
+      throw badRequest(`No system of the profiles is ${system}.`);
+    const files = [];
+    const writtenSoFar = [];
+    try {
+      if (addTeam) {
+        const t = await addRolesTeam(ctx.root, addTeam, { preview: true });
+        files.push({ file: t.rel, changes: t.changes });
+      }
+      if (owner) {
+        const m = await setManifestField(ctx.root, repo, "owner", owner, { preview: true });
+        files.push({ file: m.file.rel, changes: m.changes });
+      }
+      if (system) {
+        const m = await setManifestField(ctx.root, repo, "system", system, { preview: true });
+        const f = files.find((x) => x.file === m.file.rel);
+        if (f)
+          f.changes.push(...m.changes);
+        else
+          files.push({ file: m.file.rel, changes: m.changes });
+      }
+      if (!preview) {
+        if (owner)
+          writtenSoFar.push((await setManifestField(ctx.root, repo, "owner", owner)).file.rel);
+        if (system)
+          writtenSoFar.push((await setManifestField(ctx.root, repo, "system", system)).file.rel);
+        if (addTeam)
+          await addRolesTeam(ctx.root, addTeam);
+        for (const f of files)
+          ctx.events.publish({ type: "file.changed", path: f.file });
+      }
+    } catch (e) {
+      if (e instanceof FileChangedError)
+        throw conflict(writtenSoFar.length ? `${e.message} (${[...new Set(writtenSoFar)].join(", ")} was written already; do the rest again.)` : e.message);
+      if (e instanceof ManifestEditError)
+        throw e.code === "not-found" ? notFound(e.message) : new HttpError(422, "Atticus can't write that", e.message);
+      throw e;
+    }
+    return {
+      status: 200,
+      body: {
+        written: !preview,
+        files,
+        verify: "atticus verify --all --write",
+        commit: `git add ${files.map((f) => f.file).join(" ")}
+git commit -m "${safeMessage(`${repo}: ${[owner ? `owner ${owner}` : "", system ? `system ${system}` : ""].filter(Boolean).join(", ")}`)}"`
+      }
+    };
+  });
+}
+
+// packages/cli/dist/ui-api-declared.js
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+var REPO2 = /^[A-Za-z0-9._-]{1,200}$/;
+var says = (c) => {
+  const what = `${c.target.kind} ${c.target.value} (${c.target.file}:${c.target.line})`;
+  if (c.action === "wrong")
+    return `${what} is wrong: ${c.reason ?? ""}`.trim();
+  if (c.action === "link")
+    return `${what} goes to ${[c.link?.method, c.link?.path].filter(Boolean).join(" ")} on ${c.link?.repo ?? c.link?.system}${c.ai ? ` (detected by AI, run ${c.ai.run})` : ""}`;
+  if (c.action === "unlink")
+    return `${what} reaches none of these`;
+  const set = Object.entries(c.set ?? {}).map(([k, v]) => `${k} ${v}`).join(", ");
+  return `${what}: ${[set, c.line ? `line ${c.line}` : ""].filter(Boolean).join(", ")}`;
+};
+function uiDeclaredRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const fail2 = (e) => {
+    if (e instanceof FileChangedError)
+      throw conflict(e.message);
+    if (e instanceof DeclareError) {
+      if (e.code === "not-found")
+        throw notFound(e.message);
+      if (e.code === "exists")
+        throw conflict(e.message);
+      throw new HttpError(422, "Atticus can't write that", e.message);
+    }
+    throw e;
+  };
+  return r.add("GET", "/api/boxes/addable", async () => {
+    const op = await loadOrgPack(orgPackDirOf(ctx.root));
+    const picks = targetPicker(op, await readRepos(ctx.root));
+    return {
+      status: 200,
+      body: {
+        repos: picks.filter((p) => p.kind === "repo").map((p) => ({ id: p.id, name: p.name, read: p.read === true })),
+        systems: picks.filter((p) => p.kind === "system").map((p) => ({
+          id: p.id,
+          name: p.name,
+          ...p.boundary ? { boundary: p.boundary } : {}
+        })),
+        teams: picks.filter((p) => p.kind === "team").map((p) => ({ id: p.id, name: p.name }))
+      }
+    };
+  }).add("POST", "/api/boxes", async ({ body }) => {
+    const b = api_exports.AddSystemRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say the system's id, name and whether it is a vendor or another team's.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const op = await loadOrgPack(orgPackDirOf(ctx.root));
+    if (op.profiles.some((p) => (p.profile?.systems ?? []).some((s) => s.id === b.data.id)))
+      throw conflict(`A system of the profiles is ${b.data.id} already: it is on the picture.`);
+    const anyRepo = estateRepos(op)[0];
+    if (!anyRepo)
+      throw conflict("No repo is in a manifest yet, so there is no profile to add it to.");
+    const sys = {
+      id: b.data.id,
+      name: b.data.name,
+      boundary: b.data.boundary,
+      ...b.data.owner ? { owner: b.data.owner } : {}
+    };
+    if (b.data.preview) {
+      const res = await addProfileSystem(ctx.root, anyRepo.id, sys, { preview: true }).catch((e) => {
+        throw new HttpError(422, "Atticus can't write that", e instanceof Error ? e.message : String(e));
+      });
+      return {
+        status: 200,
+        body: {
+          written: false,
+          files: [{ file: res.profile, changes: res.changes ?? [] }],
+          verify: "atticus verify --all --write",
+          commit: ""
+        }
+      };
+    }
+    try {
+      const res = await addProfileSystem(ctx.root, anyRepo.id, sys);
+      ctx.events.publish({ type: "file.changed", path: res.profile });
+      return {
+        status: 200,
+        body: {
+          written: true,
+          files: [{ file: res.profile, changes: res.changes ?? [] }],
+          verify: "atticus verify --all --write",
+          commit: `git add ${res.profile}
+git commit -m "${safeMessage(`profile: ${b.data.id} added from the canvas`)}"`
+        }
+      };
+    } catch (e) {
+      if (e instanceof FileChangedError)
+        throw conflict(e.message);
+      throw new HttpError(422, "Atticus can't write that", e instanceof Error ? e.message : String(e));
+    }
+  }).add("POST", "/api/declared-links", async ({ body }) => {
+    const b = api_exports.DeclareLinkRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say the system and the topic with its side (publishes or listens), or the route it calls.", { errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })) });
+    const op = await loadOrgPack(orgPackDirOf(ctx.root));
+    const own = estateRepos(op).some((x) => x.system === b.data.system);
+    if (own && b.data.kind === "topic")
+      throw conflict(`${b.data.system}'s repos are in the manifest: their code says what it publishes and listens on. Read them (atticus map) rather than declaring it.`);
+    try {
+      const { preview, ...d } = b.data;
+      const res = await declareLink(ctx.root, d, {
+        by: ctx.user,
+        at: now().toISOString(),
+        ...preview ? { preview } : {}
+      });
+      if (res.written)
+        ctx.events.publish({ type: "file.changed", path: res.rel });
+      const what = d.kind === "topic" ? `${d.side} ${d.topic}` : `calls ${d.route}`;
+      return {
+        status: 200,
+        body: {
+          written: res.written,
+          files: [{ file: res.rel, changes: res.changes }],
+          verify: "atticus verify --all --write",
+          commit: `git add ${res.rel}
+git commit -m "${safeMessage(`profile: ${d.system} ${what}, declared on the canvas`)}"`
+        }
+      };
+    } catch (e) {
+      return fail2(e);
+    }
+  }).add("POST", "/api/declared-links/undo", async ({ body }) => {
+    const b = api_exports.UndeclareLinkRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which declaration: { kind, system, value }.");
+    try {
+      const res = await undeclareLink(ctx.root, b.data);
+      ctx.events.publish({ type: "file.changed", path: res.rel });
+      return {
+        status: 200,
+        body: {
+          written: true,
+          files: [{ file: res.rel, changes: res.changes }],
+          verify: "atticus verify --all --write",
+          commit: `git add ${res.rel}
+git commit -m "${safeMessage(`profile: ${b.data.system}: a declaration undone`)}"`
+        }
+      };
+    } catch (e) {
+      return fail2(e);
+    }
+  }).add("GET", "/api/boxes/corrections", async ({ query }) => {
+    const repo = query.get("repo");
+    const system = query.get("system");
+    if (!repo === !system)
+      throw badRequest("Say repo=<repo> or system=<id>.");
+    const items = [];
+    if (repo) {
+      if (!REPO2.test(repo))
+        throw badRequest(`${JSON.stringify(repo)} isn't a repo name.`);
+      const rel = `${factsRelOf(ctx.root)}/${repo}.corrections.jsonl`;
+      const text = await readFile7(join9(factsDirOf(ctx.root), `${repo}.corrections.jsonl`), "utf8").catch(() => "");
+      for (const line of text.split(/\r?\n/).filter((l) => l.trim())) {
+        const c = parseCorrections(line).corrections[0];
+        if (!c)
+          continue;
+        items.push({
+          kind: c.action,
+          says: says(c),
+          by: c.by,
+          at: c.at,
+          ...c.ai ? { ai: { runtime: c.ai.runtime, run: c.ai.run } } : {},
+          ...c.batch ? { batch: c.batch } : {},
+          file: rel,
+          undo: { repo, line }
+        });
+      }
+    } else {
+      const d = await declaredOf(ctx.root, system);
+      for (const x of d.list.filter((y) => y.by))
+        items.push({
+          kind: x.kind,
+          says: x.kind === "topic" ? `${x.side ? `${x.side} ` : ""}${x.value}` : `calls ${x.value}`,
+          ...x.by ? { by: x.by } : {},
+          ...x.at ? { at: x.at } : {},
+          file: d.rel,
+          undo: { kind: x.kind, system: x.system, value: x.value }
+        });
+    }
+    return { status: 200, body: { items } };
+  });
+}
+
+// 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_yaml6 = __toESM(require_dist(), 1);
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join10, 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", "decide"];
+function uiAiRoutes(r, ctx, deps = {}) {
+  const root = ctx.root;
+  const env = deps.env ?? process.env;
+  const keys = () => deps.keys ?? defaultKeyStore();
+  const file = () => join10(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,
+        // Ninth UX walk (ADR 0181): whether the AI decides first, and the bar that pauses it.
+        decide: decideOf(rt),
+        schemaVersion: rt.schemaVersion,
+        path: rel()
+      }
+    };
+  }).add("PUT", "/api/settings/ai", async ({ body }) => {
+    const b = body ?? {};
+    const text = existsSync3(file()) ? await readFile8(file(), "utf8") : void 0;
+    const raw = text !== void 0 ? (0, import_yaml6.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 names = (m) => {
+      const x = m;
+      return [...x?.allowed ?? [], x?.default].includes("copilot-acp");
+    };
+    const lifted = names(b.modes) && raw.schemaVersion === 2;
+    if (lifted)
+      raw.schemaVersion = 3;
+    const liftedDecide = b.decide !== void 0 && raw.schemaVersion === 3;
+    if (liftedDecide)
+      raw.schemaVersion = 4;
+    const checked = Runtime.safeParse(raw);
+    if (!checked.success)
+      throw unprocessable(checked.error.issues.map((i) => `${i.path.join(".") || "runtime.yaml"}: ${i.message}`).join("; "));
+    const out = (() => {
+      if (text === void 0)
+        return (0, import_yaml6.stringify)(raw, { lineWidth: 0 });
+      const doc = (0, import_yaml6.parseDocument)(text);
+      for (const f of FIELDS)
+        if (b[f] !== void 0)
+          doc.set(f, raw[f]);
+      if (b.model !== void 0)
+        doc.set("adapters", raw.adapters);
+      if (lifted || liftedDecide)
+        doc.set("schemaVersion", raw.schemaVersion);
+      return doc.toString({ lineWidth: 0 });
+    })();
+    await writeFileIfUnchanged(file(), text, inEol(out, eolOf(text ?? "")));
+    return {
+      status: 200,
+      body: {
         ok: true,
         path: rel(),
-        note: `Saved ${rel()}. Commit it in a pull request: the org pack is reviewed like code.`
+        note: `Saved ${rel()}. Propose it for review: the org pack is reviewed like code.`
       }
     };
   }).add("POST", "/api/settings/ai/key", async ({ body }) => {
@@ -3230,7 +5167,7 @@ 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-ONLS5QA5.js");
+    const { listDocuments } = await import("./chunk-URIKUID7.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 ?? {});
@@ -3239,7 +5176,7 @@ function uiDocumentRoutes(r, ctx) {
     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-W3BQAZ3Q.js");
+    const { addToInbox } = await import("./chunk-ZKYRDV7A.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 ?? "", {
@@ -3249,7 +5186,7 @@ function uiDocumentRoutes(r, ctx) {
       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-NE2W3OO7.js");
+    const { AttachError, promoteChangeInput } = await import("./chunk-XQ3YZ4QW.js");
     try {
       const res = await promoteChangeInput(root, params.changeId, params.name);
       changed(res.path);
@@ -3266,13 +5203,13 @@ function uiDocumentRoutes(r, ctx) {
 function uiRepoRoutes(r, ctx) {
   const root = ctx.root;
   return r.add("GET", "/api/repos/branches", async () => {
-    const { repoBranches } = await import("./chunk-64EQYWCA.js");
+    const { repoBranches } = await import("./chunk-YBOVNMHC.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-64EQYWCA.js");
+    const { compareBranch } = await import("./chunk-YBOVNMHC.js");
     const c = await compareBranch(root, branch);
     if (!c)
       throw notFound(`${branch} hasn't been scanned beside the baseline yet.`);
@@ -3281,7 +5218,7 @@ function uiRepoRoutes(r, ctx) {
     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-64EQYWCA.js");
+    const { editRepoBranches, RepoEditError } = await import("./chunk-YBOVNMHC.js");
     try {
       const file = await editRepoBranches(root, params.repoId, b.data);
       ctx.events.publish({ type: "file.changed", path: file });
@@ -3294,14 +5231,56 @@ function uiRepoRoutes(r, ctx) {
       };
     } catch (e) {
       if (e instanceof RepoEditError)
-        throw e.code === "not-found" ? notFound(e.message) : badRequest(e.message);
+        throw e.code === "not-found" ? notFound(e.message) : e.code === "conflict" ? conflict(e.message) : badRequest(e.message);
+      throw e;
+    }
+  }).add("PUT", "/api/repos/{repoId}/build", async ({ params, body }) => {
+    const b = api_exports.EditRepoBuildRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest('Send the build command as build ("" clears it), up to 500 characters.');
+    const { editRepoBuild, RepoEditError } = await import("./chunk-YBOVNMHC.js");
+    try {
+      const r2 = await editRepoBuild(root, params.repoId, b.data);
+      ctx.events.publish({ type: "file.changed", path: r2.file });
+      return {
+        status: 200,
+        body: {
+          file: r2.file,
+          ...r2.build ? { build: r2.build } : {},
+          note: r2.build ? `${r2.file} changed: propose it for review. A task in ${params.repoId} is now built and tested with it before its PR is raised; run the task again.` : `${r2.file} changed: propose it for review. ${params.repoId} has no build command now, so its tasks aren't built or tested.`
+        }
+      };
+    } catch (e) {
+      if (e instanceof RepoEditError)
+        throw e.code === "not-found" ? notFound(e.message) : e.code === "conflict" ? conflict(e.message) : badRequest(e.message);
+      throw e;
+    }
+  }).add("PUT", "/api/orgpack/owner", async ({ body }) => {
+    const b = api_exports.SetOrgPackOwnerRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Send the owner as one handle: { owner }.");
+    const { setOrgPackOwner, OwnerEditError } = await import("./chunk-PQH56YF6.js");
+    try {
+      const r2 = await setOrgPackOwner(root, b.data.owner, b.data.was);
+      ctx.events.publish({ type: "file.changed", path: r2.file });
+      return {
+        status: 200,
+        body: {
+          file: r2.file,
+          owner: r2.owner,
+          note: `${r2.owner} now looks after the org pack. ${r2.file} changed: propose it for review; its owner approves changes to the org pack.`
+        }
+      };
+    } catch (e) {
+      if (e instanceof OwnerEditError)
+        throw e.code === "not-found" ? notFound(e.message) : e.code === "conflict" ? conflict(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-64EQYWCA.js");
+    const { editRepoDescription, RepoEditError } = await import("./chunk-YBOVNMHC.js");
     try {
       const r2 = await editRepoDescription(root, params.repoId, b.data);
       ctx.events.publish({ type: "file.changed", path: r2.file });
@@ -3315,7 +5294,7 @@ function uiRepoRoutes(r, ctx) {
       };
     } catch (e) {
       if (e instanceof RepoEditError)
-        throw e.code === "not-found" ? notFound(e.message) : badRequest(e.message);
+        throw e.code === "not-found" ? notFound(e.message) : e.code === "conflict" ? conflict(e.message) : badRequest(e.message);
       throw e;
     }
   });
@@ -3324,11 +5303,11 @@ function uiRepoRoutes(r, ctx) {
 // 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-EDS2L2LD.js");
+    const { cockpit } = await import("./chunk-6EXDI5GI.js");
     try {
       return {
         status: 200,
-        body: api_exports.ChangeCockpit.parse(await cockpit(ctx.root, params.changeId))
+        body: api_exports.ChangeCockpit.parse(await cockpit(ctx.root, params.changeId, { user: ctx.user }))
       };
     } catch (e) {
       if (e instanceof Error && e.name === "ChangeFileError")
@@ -3336,17 +5315,17 @@ function uiCockpitRoutes(r, ctx) {
       throw e;
     }
   }).add("GET", "/api/past-changes", async ({ query }) => {
-    const { changeAboutText, similarChanges } = await import("./chunk-HVUPKCGJ.js");
+    const { changeAboutText, similarChanges } = await import("./chunk-BC6KKZ67.js");
     const change = query.get("change");
-    const text2 = change ? await changeAboutText(ctx.root, change) : query.get("text")?.trim();
-    if (change && !text2)
+    const text = change ? await changeAboutText(ctx.root, change) : query.get("text")?.trim();
+    if (change && !text)
       throw notFound(`There is no change ${change}.`);
-    if (!text2)
+    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, text2.slice(0, 2e4), {
+      body: api_exports.SimilarChanges.parse(await similarChanges(ctx.root, text.slice(0, 2e4), {
         limit: Number.isInteger(limit) && limit > 0 && limit <= 20 ? limit : 5
       }))
     };
@@ -3354,11 +5333,11 @@ function uiCockpitRoutes(r, ctx) {
     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-HVUPKCGJ.js");
+    const { attachPastChange, findPastChange } = await import("./chunk-BC6KKZ67.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-NE2W3OO7.js");
+    const { AttachError } = await import("./chunk-XQ3YZ4QW.js");
     try {
       const name = await attachPastChange(ctx.root, params.changeId, folder, ctx.user);
       ctx.events.publish({ type: "file.changed", path: `inputs/${name}` });
@@ -3374,396 +5353,521 @@ function uiCockpitRoutes(r, ctx) {
   });
 }
 
-// packages/cli/dist/ui-api-trust.js
-var import_yaml6 = __toESM(require_dist(), 1);
-import { readdir as readdir3, readFile as readFile7, stat as stat4 } from "node:fs/promises";
-import { join as join9, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
-var SHA = /^[0-9a-f]{7,64}$/;
-var FULL_SHA = /^[0-9a-f]{40,64}$/;
-var FACT_BY = /* @__PURE__ */ new Set(["assistant", "reader", "person"]);
-var UNKNOWN_SHOWN = 50;
-var firstLine = (e) => String(e.message ?? e).split("\n")[0];
-var text = (p) => readFile7(p, "utf8").catch(() => void 0);
-async function headFromFiles(dir) {
-  let git = join9(dir, ".git");
-  const st = await stat4(git).catch(() => void 0);
-  if (!st)
-    return void 0;
-  if (st.isFile()) {
-    const m = /^gitdir:\s*(.+)$/m.exec(await text(git) ?? "");
-    if (!m)
-      return void 0;
-    git = resolve2(dir, m[1].trim());
-  }
-  const common = (await text(join9(git, "commondir")))?.trim();
-  const commonDir = common ? resolve2(git, common) : git;
-  const head = (await text(join9(git, "HEAD")) ?? "").trim();
-  if (FULL_SHA.test(head))
-    return head;
-  const ref = /^ref:\s*(refs\/[A-Za-z0-9._/-]+)$/.exec(head)?.[1];
-  if (!ref || ref.split("/").includes(".."))
-    return void 0;
-  for (const d of [git, commonDir]) {
-    const loose = (await text(join9(d, ...ref.split("/"))) ?? "").trim();
-    if (FULL_SHA.test(loose))
-      return loose;
-  }
-  for (const line of (await text(join9(commonDir, "packed-refs")) ?? "").split(/\r?\n/)) {
-    const [sha2, name] = line.split(" ");
-    if (name === ref && sha2 && FULL_SHA.test(sha2))
-      return sha2;
-  }
-  return void 0;
+// packages/cli/dist/ui-api-audit.js
+var REPO3 = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+var repoOf = (v) => {
+  if (!REPO3.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 } : {} };
+    })
+  }));
 }
-function reportOf(raw) {
-  const r = raw;
-  if (!r || typeof r.accepted !== "number" || typeof r.rejected !== "number")
-    return "not a verifier's report: accepted and rejected are missing";
-  const list = (v) => Array.isArray(v) ? v.map(String) : [];
-  const unknown = list(r.coverage?.unknown);
-  return {
-    accepted: r.accepted,
-    rejected: r.rejected,
-    redacted: typeof r.redacted === "number" ? r.redacted : 0,
-    coverage: {
-      ratio: typeof r.coverage?.ratio === "number" ? r.coverage.ratio : 0,
-      read: typeof r.coverage?.read === "number" ? r.coverage.read : 0,
-      unknown: unknown.length,
-      excluded: list(r.coverage?.excluded).length
-    },
-    unknownFiles: unknown.slice(0, UNKNOWN_SHOWN),
-    ...typeof r.commit === "string" && SHA.test(r.commit) ? { commit: r.commit } : {}
-  };
+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 };
+  });
 }
-var sameCommit = (a, b) => a && b ? a.startsWith(b) || b.startsWith(a) : null;
-function nextOf(repo, r) {
-  const read = { command: `atticus map ${repo}`, slash: `/atticus-map ${repo}` };
-  if (!r.facts.present)
-    return { state: "not-read", next: read };
-  const report = r.verify.report;
-  if (!report)
-    return { state: "unverified", next: { command: `atticus verify ${repo}` } };
-  if (report.rejected > 0)
-    return {
-      state: "rejected",
-      next: { command: `atticus verify ${repo}`, slash: `/atticus-map ${repo}` }
-    };
-  if (r.sameCommit === false)
-    return { state: "stale", next: read };
-  if (r.facts.unverified > 0)
-    return { state: "unverified", next: { command: `atticus verify ${repo}` } };
-  if (r.catalog.fromFacts === 0)
-    return { state: "unwritten", next: { command: `atticus verify ${repo} --write` } };
-  if (report.coverage.unknown > 0)
-    return { state: "unknown-files", next: read };
-  return { state: "trusted" };
-}
-async function trustView(root) {
-  const rel = (p) => relative2(root, p).split(sep2).join("/") || ".";
-  const problems = [];
-  const dir = factsDirOf(root);
-  const factsRel = factsRelOf(root);
-  const ids = [];
-  try {
-    for (const r of await loadRepos(root))
-      ids.push(r.id);
-  } catch (e) {
-    problems.push({ file: "org-pack/profiles", message: firstLine(e) });
-  }
-  const files = await readdir3(dir).catch(() => []);
-  const named = /* @__PURE__ */ new Set();
-  for (const f of files) {
-    const of = factsFileOf(f);
-    if (of && (of.facts || f.endsWith(".verify.yaml")))
-      named.add(of.repo);
+
+// packages/cli/dist/ui-api-outside.js
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join11 } 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 stamp2 = await stampOf(root);
+  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 = await estateJoinOnFile(root, op, estate, stamp2);
+  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 readFile9(join11(inputsDirOf(root), ...d.path.split("/").slice(1)), "utf8");
+    const spec = readVendorSpec(d.path, body, system.id);
+    if (spec)
+      specs.set(system.id, spec);
   }
-  for (const id of [...named].sort())
-    if (!ids.includes(id))
-      ids.push(id);
-  const catalog = await readCatalog(join9(catalogDirOf(root), "generated"), { cacheRoot: root });
-  for (const p of catalog.problems)
-    problems.push({ file: rel(join9(catalogDirOf(root), "generated", p.file)), message: p.message });
-  const counts = /* @__PURE__ */ new Map();
-  const count = (r) => {
-    const seen = /* @__PURE__ */ new Map();
-    for (const e of r.evidence) {
-      if (!e.repo)
-        continue;
-      const s = seen.get(e.repo) ?? { facts: false, readers: false };
-      if (!e.extractor && e.by && FACT_BY.has(e.by))
-        s.facts = true;
-      else if (e.source !== "manual")
-        s.readers = true;
-      seen.set(e.repo, s);
-    }
-    for (const [repo, s] of seen) {
-      const c = counts.get(repo) ?? { facts: 0, readers: 0 };
-      if (s.facts)
-        c.facts += 1;
-      else if (s.readers)
-        c.readers += 1;
-      counts.set(repo, c);
-    }
+  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 contracts = await contractCheckOf(root).catch(() => void 0);
+  const catalog = records.length ? records : (await readCatalog(join11(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 } : {}
+    };
   };
-  for (const r of catalog.records)
-    count(r);
-  const adopted = isAdopted(root);
-  const repos = [];
-  for (const repo of ids) {
-    const factsPath = join9(dir, `${repo}.jsonl`);
-    const raw = await text(factsPath);
-    const facts = {
-      path: rel(factsPath),
-      present: raw !== void 0,
-      count: 0,
-      unverified: 0
-    };
-    let frameworks;
-    if (raw !== void 0 && raw.trim()) {
-      const parsed = parseFacts(raw);
-      if (parsed.ok) {
-        facts.count = parsed.facts.length;
-        facts.unverified = parsed.facts.filter((f) => f.verified === "none").length;
-        const commit = parsed.facts[0]?.commit;
-        if (commit)
-          facts.commit = commit;
-        const gaps = new Map(frameworkGaps(parsed.facts).map((g) => [g.id, g.question]));
-        const built = frameworkFacts(parsed.facts).map((f) => ({
-          name: f.name,
-          ...f.version ? { version: f.version } : {},
-          ...f.component ? { component: f.component } : {},
-          cite: `${f.cite.file}:${f.cite.line}`,
-          ...gaps.has(f.id) ? { gap: gaps.get(f.id) } : {}
-        }));
-        if (built.length)
-          frameworks = built;
+  const contractsOf = (id) => {
+    const findings = contracts?.result.findings.filter((f) => f.system === id) ?? [];
+    const fresh = contracts?.newBySystem.get(id);
+    if (!findings.length && !fresh)
+      return {};
+    return {
+      contracts: { findings, ...fresh ? { new: fresh.map((f) => f.id) } : {} }
+    };
+  };
+  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
-        problems.push({
-          file: rel(factsPath),
-          message: `doesn't read as facts: ${parsed.issues[0]?.message ?? "invalid"}`
-        });
-    }
-    const reportPath = join9(dir, `${repo}.verify.yaml`);
-    let report = null;
-    const reportText = await text(reportPath);
-    if (reportText !== void 0) {
-      try {
-        const r = reportOf((0, import_yaml6.parse)(reportText));
-        if (typeof r === "string")
-          problems.push({ file: rel(reportPath), message: r });
-        else
-          report = r;
-      } catch (e) {
-        problems.push({ file: rel(reportPath), message: `can't read YAML: ${firstLine(e)}` });
-      }
+        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");
     }
-    if (!facts.commit && report?.commit)
-      facts.commit = report.commit;
-    let checkoutDir;
-    try {
-      checkoutDir = adopted ? root : baseClonePath(root, repo);
-    } catch {
-      checkoutDir = void 0;
+    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");
     }
-    const head = checkoutDir ? await headFromFiles(checkoutDir) : void 0;
-    const present = checkoutDir ? await stat4(join9(checkoutDir, ".git")).then(() => true, () => false) : false;
-    const checkout = {
-      path: checkoutDir ? rel(checkoutDir) : `workspace/${repo}`,
-      present,
-      ...head ? { commit: head } : {}
+    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) },
+      ...contractsOf(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 }))
+        }
+      } : {}
     };
-    const c = counts.get(repo) ?? { facts: 0, readers: 0 };
-    const from = c.facts && c.readers ? "both" : c.facts ? "facts" : c.readers ? "readers" : "none";
-    const base = {
-      repo,
-      facts,
-      verify: { path: rel(reportPath), report },
-      checkout,
-      sameCommit: sameCommit(report?.commit ?? facts.commit, head),
-      catalog: { from, fromFacts: c.facts, fromReaders: c.readers }
-    };
-    const { state, next } = nextOf(repo, base);
-    repos.push({
-      ...base,
-      state,
-      ...next ? { next } : {},
-      ...frameworks ? { frameworks } : {}
-    });
-  }
-  return { factsDir: factsRel, repos, problems };
+  });
+  return { systems: out, notes: estate.notes };
 }
-function uiTrustRoutes(r, ctx) {
-  return r.add("GET", "/api/trust", async () => ({ status: 200, body: await trustView(ctx.root) }));
+function uiOutsideRoutes(r, ctx) {
+  return r.add("GET", "/api/outside", async () => ({
+    status: 200,
+    body: await outsideView(ctx.root)
+  }));
 }
 
-// packages/cli/dist/ui-api-facts.js
-import { appendFile, mkdir, readFile as readFile8 } from "node:fs/promises";
-import { join as join10 } from "node:path";
-var REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
-var fixed = new Set(FACT_FIXED_FIELDS);
-function factLabel(f) {
-  switch (f.kind) {
-    case "entry":
-      return `${f.method ? `${f.method} ` : ""}${f.path}`;
-    case "call":
-      return `${f.method ? `${f.method} ` : ""}${f.path}${f.to ? ` \u2192 ${f.to}` : ""}`;
-    case "store":
-      return `${f.name} (${f.op})`;
-    case "field":
-      return `${f.name}${f.type ? `: ${f.type}` : ""}`;
-    case "deploy":
-      return `${f.platform}${f.resourceName ? ` ${f.resourceName}` : ""}`;
-    case "config":
-      return `${f.key}${f.value !== void 0 ? ` = ${f.value}` : ""}`;
-    // ADR 0124 addendum A-framework: what the repo or the module is built on.
-    case "framework":
-      return `${f.name}${f.version ? ` ${f.version}` : ""}`;
-    case "flow":
-      return f.name;
-  }
+// packages/cli/dist/ui-api-contracts.js
+async function contractsView(root, check = contractCheckOf) {
+  const { result, notes } = await check(root);
+  return { links: result.links, findings: result.findings, counts: result.counts, notes };
 }
-function claimOf(f) {
-  const out = {};
-  for (const [k, v] of Object.entries(f))
-    if (!fixed.has(k) && typeof v === "string")
-      out[k] = v;
-  out.value = f.cite.value;
+function uiContractsRoutes(r, ctx, o = {}) {
+  return r.add("GET", "/api/contracts", async () => ({
+    status: 200,
+    body: await contractsView(ctx.root, o.check)
+  }));
+}
+
+// packages/cli/dist/ui-api-stages.js
+var import_yaml7 = __toESM(require_dist(), 1);
+import { createHash as createHash4 } from "node:crypto";
+import { readFile as readFile11, stat as stat6 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+
+// packages/cli/dist/ui-api-drafts.js
+import { readdir as readdir4, readFile as readFile10, stat as stat5 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+var ID3 = /^[a-z0-9][a-z0-9._-]{0,99}$/;
+var CORRECTION_ID = /^c-[0-9a-f]{10}$/;
+var exists2 = (p) => stat5(p).then(() => true, () => false);
+var PAGE_STAGE = {
+  feature: "feature",
+  architecture: "architecture",
+  stories: "stories",
+  tasks: "stories"
+};
+var ON_PAGE = {
+  feature: (f) => f === "feature.md" || f === "proposal.md",
+  architecture: (f) => /^target-flows\/[^/]+\.ya?ml$/.test(f) || f === "design.md" || f === "data.md",
+  stories: (f) => f === "stories.md" || /^stories\/[^/]+\.md$/.test(f) || /^specs\/.+\/spec\.md$/.test(f),
+  tasks: (f) => f === "tasks.md"
+};
+var pageOfFile = (f) => Object.keys(ON_PAGE).find((p) => ON_PAGE[p](f));
+async function walk(dir, sub = "") {
+  const out = [];
+  for (const e of await readdir4(join12(dir, sub), { withFileTypes: true }).catch(() => [])) {
+    if (e.name.startsWith("."))
+      continue;
+    const rel = sub ? `${sub}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      if (["stage", "review", "tasks", "inputs"].includes(rel))
+        continue;
+      out.push(...await walk(dir, rel));
+    } else
+      out.push(rel);
+  }
   return out;
 }
-var spot = (c) => ({
-  file: c.file,
-  line: c.line,
-  value: c.value,
-  ...c.quote ? { quote: c.quote } : {}
+var slashOf = (stage, change) => `/atticus-${stage === "small" ? "small" : stage} ${change}`;
+var nextOf = (stage, change) => ({
+  stage,
+  command: rerunOf(stage, change),
+  slash: slashOf(stage, change)
 });
-async function readFacts(root, repo) {
-  const file = `${factsRelOf(root)}/${repo}.jsonl`;
-  const text2 = await readFile8(join10(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
-  if (text2 === void 0)
-    return { file, present: false, facts: [], bad: [] };
-  const p = parseFactsLines(text2);
-  return {
-    file,
-    present: true,
-    facts: p.facts,
-    bad: p.bad.map((b) => ({
-      file,
-      message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
-    }))
-  };
+var view = (c) => ({ ...c });
+async function writtenByStage(dir, change) {
+  const out = [];
+  for (const s of STAGES) {
+    const l = await readStageLoop(dir, change, s).catch(() => void 0);
+    if (l?.present && l.loop.written)
+      out.push({ stage: s, hashes: l.loop.written });
+  }
+  return out;
 }
-async function repoFactsView(root, repo) {
-  const f = await readFacts(root, repo);
-  const cFile = `${factsRelOf(root)}/${repo}.corrections.jsonl`;
-  const c = await readCorrections(root, repo);
-  const problems = [
-    ...f.bad,
-    ...c.bad.map((b) => ({
-      file: cFile,
-      message: `line ${b.line} isn't a correction: ${b.message}`
-    }))
-  ];
-  const facts = f.facts.map((x) => {
-    const corr = correctionFor(x, c.corrections);
-    return {
-      id: x.id,
-      kind: x.kind,
-      label: factLabel(x),
-      claim: claimOf(x),
-      cite: spot(x.cite),
-      ...x.kind === "flow" ? {
-        steps: [
-          ...x.steps.map((s) => ({ ...spot(s.cite), what: s.what })),
-          ...x.errors.map((e) => ({ ...spot(e.cite), what: `${e.when} \u2192 ${e.then}` }))
-        ]
-      } : {},
-      verified: x.verified,
-      by: x.by,
-      ...corr ? { correction: corr } : {}
-    };
+var provenanceView = (p) => ({ ...p });
+async function stageDraftsView(root, change, page) {
+  const dir = changeFolder(root, change);
+  const rel = `${changesRelOf(root)}/${change}`;
+  const problems = [];
+  const candidates = (await walk(dir)).filter(ON_PAGE[page]).sort();
+  const prov = await draftProvenance(dir, change, candidates, await writtenByStage(dir, change)).catch((e) => {
+    problems.push({ file: `${rel}/stage/drafted.yaml`, message: String(e.message) });
+    return {};
   });
-  const stale = applyCorrections(f.facts, c.corrections).stale.filter((s) => s.why === "none").map((s) => s.correction.fact);
-  const questions = await listQuestions(root, { repo, state: "open" }).then((l) => l.questions.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })), () => []);
+  const files = [];
+  for (const f of candidates) {
+    const p = prov[f];
+    if (!p)
+      continue;
+    const text = await readFile10(join12(dir, ...f.split("/")), "utf8").catch(() => "") ?? "";
+    files.push({
+      file: f,
+      path: `${rel}/${f}`,
+      stage: p.by === "ai" ? p.stage : PAGE_STAGE[page],
+      drafted: provenanceView(p),
+      items: draftItems(f, text)
+    });
+  }
+  let corrections = [];
+  try {
+    corrections = await readCorrections(dir, change);
+  } catch (e) {
+    problems.push({ file: `${rel}/${CORRECTIONS_FILE}`, message: String(e.message) });
+  }
+  const mine = corrections.filter((c) => ON_PAGE[page](c.file)).sort((a, b) => a.at < b.at ? -1 : a.at > b.at ? 1 : 0);
+  const waiting = mine.find((c) => c.state === "waiting");
   return {
-    repo,
-    file: f.file,
-    present: f.present,
-    ...f.facts[0] ? { commit: f.facts[0].commit } : {},
-    facts,
-    corrections: { file: cFile, count: c.corrections.length, stale: [...new Set(stale)].sort() },
-    questions,
-    verify: `atticus verify ${repo}`,
+    change,
+    page,
+    files,
+    corrections: mine.map(view),
+    next: nextOf(waiting?.stage ?? PAGE_STAGE[page], change),
     problems
   };
 }
-var repoOf = (v) => {
-  if (!REPO.test(v))
-    throw badRequest(`${JSON.stringify(v)} isn't a repo name.`);
-  return v;
+function pageOf(v) {
+  const r = api_exports.DraftPage.safeParse(v);
+  if (!r.success)
+    throw badRequest(`${JSON.stringify(v)} isn't a page of drafts: feature, architecture, stories or tasks.`);
+  return r.data;
+}
+var refusal = (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;
 };
-function uiFactsRoutes(r, ctx, deps = {}) {
+function uiDraftRoutes(r, ctx, deps = {}) {
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
-  return r.add("GET", "/api/facts/{repo}", async ({ params }) => ({
-    status: 200,
-    body: await repoFactsView(ctx.root, repoOf(params.repo))
-  })).add("POST", "/api/facts/{repo}/corrections", async ({ params, body }) => {
-    const repo = repoOf(params.repo);
-    const b = api_exports.FactCorrectionRequest.safeParse(body ?? {});
+  const changeOf = async (v) => {
+    if (!ID3.test(v))
+      throw badRequest(`${JSON.stringify(v)} isn't a change id.`);
+    if (!await exists2(join12(changeFolder(ctx.root, v), "change.yaml")))
+      throw notFound(`There is no change ${v}.`);
+    return v;
+  };
+  const list = async (change) => ({
+    change,
+    corrections: (await readCorrections(changeFolder(ctx.root, change), change).catch(refusal)).map(view)
+  });
+  return r.add("GET", "/api/changes/{changeId}/drafts/{page}", async ({ params }) => {
+    const page = pageOf(params.page);
+    const change = await changeOf(params.changeId);
+    return { status: 200, body: await stageDraftsView(ctx.root, change, page) };
+  }).add("GET", "/api/changes/{changeId}/corrections", async ({ params }) => {
+    const change = await changeOf(params.changeId);
+    return { status: 200, body: await list(change) };
+  }).add("POST", "/api/changes/{changeId}/corrections", async ({ params, body }) => {
+    const change = await changeOf(params.changeId);
+    const b = api_exports.AddCorrectionRequest.safeParse(body ?? {});
     if (!b.success)
-      throw badRequest("Say which fact and what is wrong: { fact, action, set, line, reason }.", {
+      throw badRequest("Say which draft (file, and item) and write the correction: { file, item, text }.", {
         errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
       });
-    const f = await readFacts(ctx.root, repo);
-    if (!f.present)
-      throw notFound(`There are no facts for ${repo} at ${f.file}.`);
-    const fact = f.facts.find((x) => x.id === b.data.fact);
-    if (!fact)
-      throw notFound(`${f.file} has no fact ${b.data.fact}.`);
-    const was = claimOf(fact);
-    const set = Object.fromEntries(Object.entries(b.data.set ?? {}).map(([k, v]) => [k, v.trim()]).filter(([k, v]) => was[k] !== v));
-    const line = b.data.line !== void 0 && b.data.line !== fact.cite.line ? b.data.line : void 0;
-    const c = FactCorrection.safeParse({
-      schemaVersion: 1,
-      fact: fact.id,
-      target: {
-        kind: fact.kind,
-        file: fact.cite.file,
-        line: fact.cite.line,
-        value: fact.cite.value
-      },
-      action: b.data.action,
-      ...b.data.action === "edit" && Object.keys(set).length ? { set } : {},
-      ...b.data.action === "edit" && line !== void 0 ? { line } : {},
-      ...b.data.reason ? { reason: b.data.reason } : {},
+    const page = pageOfFile(b.data.file);
+    if (!page)
+      throw notFound(`${b.data.file} isn't a stage draft of ${change}.`);
+    const v = await stageDraftsView(ctx.root, change, page);
+    const f = v.files.find((x) => x.file === b.data.file);
+    if (!f)
+      throw notFound(`${b.data.file} isn't a stage draft of ${change}.`);
+    const item = b.data.item ? f.items.find((i) => i.id === b.data.item) : void 0;
+    if (b.data.item && !item)
+      throw notFound(`${b.data.file} has no item ${b.data.item} now: reload the page, then correct it again.`);
+    const stage = f.stage;
+    const dir = changeFolder(ctx.root, change);
+    const { present } = await readStageLoop(dir, change, stage);
+    if (!present)
+      throw conflict(`The ${stage} stage of ${change} hasn't run here yet, so nothing would read a correction: run ${rerunOf(stage, change)} first.`);
+    const c = await addCorrection(dir, change, {
+      stage,
+      file: f.file,
+      ...item ? { item: item.id } : {},
+      label: item?.label ?? f.file,
+      text: b.data.text,
+      similar: b.data.similar,
+      ...b.data.like ? { like: b.data.like } : item?.like?.[0] ? { like: item.like[0] } : {},
       by: ctx.user,
       at: now().toISOString()
-    });
-    if (!c.success)
-      throw new HttpError(422, "Atticus can't record that", c.error.issues.map((i) => i.message).join("; "));
-    if (c.data.action === "edit") {
-      const fixedFact = correctedFact(fact, c.data);
-      if (typeof fixedFact === "string")
-        throw new HttpError(422, "That isn't a fact", `The corrected ${fact.kind} isn't one: ${fixedFact}.`);
-    }
-    const rel = `${factsRelOf(ctx.root)}/${repo}.corrections.jsonl`;
-    await mkdir(factsDirOf(ctx.root), { recursive: true });
-    await appendFile(join10(factsDirOf(ctx.root), `${repo}.corrections.jsonl`), `${correctionLine(c.data)}
-`, "utf8");
-    ctx.events.publish({ type: "file.changed", path: rel });
+    }).catch(refusal);
+    const written = `${changesRelOf(ctx.root)}/${change}/${CORRECTIONS_FILE}`;
+    ctx.events.publish({ type: "file.changed", path: written });
     const result = {
-      correction: c.data,
-      file: rel,
-      commit: `git add ${rel} && git commit -m "${repo}: a person's correction of ${fact.id}"`,
-      verify: `atticus verify ${repo}`
+      correction: view(c),
+      files: [written],
+      commit: `git add ${written}
+git commit -m "${change}: a correction of ${f.file}"`,
+      next: nextOf(stage, change)
     };
     return { status: 200, body: result };
+  }).add("POST", "/api/changes/{changeId}/corrections/{correctionId}/remove", async ({ params }) => {
+    const change = await changeOf(params.changeId);
+    const id = params.correctionId;
+    if (!CORRECTION_ID.test(id))
+      throw badRequest(`${JSON.stringify(id)} isn't a correction id.`);
+    const gone = await removeCorrection(changeFolder(ctx.root, change), change, id).catch(refusal);
+    if (!gone)
+      throw notFound(`Change ${change} has no correction ${id}.`);
+    ctx.events.publish({
+      type: "file.changed",
+      path: `${changesRelOf(ctx.root)}/${change}/${CORRECTIONS_FILE}`
+    });
+    return { status: 200, body: await list(change) };
   });
 }
 
 // packages/cli/dist/ui-api-stages.js
-import { stat as stat5 } from "node:fs/promises";
-import { join as join11 } from "node:path";
-var ID2 = /^[a-z0-9][a-z0-9._-]{0,99}$/;
+var ID4 = /^[a-z0-9][a-z0-9._-]{0,99}$/;
 function findingOptions(f) {
   const open = f.state === "open";
   const issue = f.kind === "issue";
@@ -3775,8 +5879,8 @@ function findingOptions(f) {
     ...open && f.question ? { ask: { text: f.question.text, owner: f.question.owner } } : {}
   };
 }
-var exists2 = (p) => stat5(p).then(() => true, () => false);
-var slashOf = (stage, change) => `/atticus-${stage} ${change}`;
+var exists3 = (p) => stat6(p).then(() => true, () => false);
+var slashOf2 = (stage, change) => `/atticus-${stage} ${change}`;
 async function gateOf(root, change, stage) {
   const problems = [];
   let gate;
@@ -3802,7 +5906,7 @@ async function latest(root, change, gate) {
   const r = await readRound(root, change, gate, round);
   return { round, findings: r.findings, bad: r.bad };
 }
-var view = (c) => ({
+var view2 = (c) => ({
   question: c.question,
   text: c.text,
   by: c.by,
@@ -3826,7 +5930,7 @@ async function stageReviewView(root, change, stage) {
       finding: s.finding,
       file: fileRel,
       options: findingOptions(s.finding),
-      comments: comments.comments.filter((c) => c.about === fileRel).map(view),
+      comments: comments.comments.filter((c) => c.about === fileRel).map(view2),
       ...p ? {
         proposal: {
           claim: p.claim,
@@ -3859,10 +5963,37 @@ async function stageReviewView(root, change, stage) {
     },
     findings,
     questions,
-    next: { command: rerunOf(stage, change), slash: slashOf(stage, change) },
+    next: { command: rerunOf(stage, change), slash: slashOf2(stage, change) },
     problems
   };
 }
+var PLACED_HEAD = "# The feature placed against the estate (ADR 0087).";
+var EDITED = /^# The feature placed against the estate \(ADR 0087\)\. Edited by (.+) on (\S+); /;
+var sha3 = (s) => createHash4("sha256").update(s).digest("hex");
+function draftedOf(text) {
+  const head = text.split("\n", 1)[0] ?? "";
+  if (head.startsWith(PLACED_HEAD) && / Drafted by /.test(head))
+    return { by: "ai" };
+  const m = EDITED.exec(head);
+  return m ? { by: "person", who: m[1], at: m[2] } : { by: "person" };
+}
+async function placementView(root, change) {
+  const rel = `${changesRelOf(root)}/${change}`;
+  const dir = changeFolder(root, change);
+  const read = (f) => readFile11(join13(dir, f), "utf8").catch(() => void 0);
+  const source = await read(FEATURE_FILE);
+  const content = await read("feature.md") ?? "";
+  return {
+    change,
+    present: source !== void 0,
+    file: `${rel}/feature.md`,
+    content,
+    source: `${rel}/${FEATURE_FILE}`,
+    sourceContent: source ?? "",
+    sha256: sha3(source ?? ""),
+    ...source !== void 0 ? { drafted: draftedOf(source) } : {}
+  };
+}
 function tabOf(v) {
   const r = api_exports.StageTab.safeParse(v);
   if (!r.success)
@@ -3872,13 +6003,57 @@ function tabOf(v) {
 function uiStageRoutes(r, ctx, deps = {}) {
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const changeOf = async (v) => {
-    if (!ID2.test(v))
+    if (!ID4.test(v))
       throw badRequest(`${JSON.stringify(v)} isn't a change id.`);
-    if (!await exists2(join11(changeFolder(ctx.root, v), "change.yaml")))
+    if (!await exists3(join13(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 }) => {
+  return uiDraftRoutes(r, ctx, deps).add("GET", "/api/changes/{changeId}/placement", async ({ params }) => {
+    const change = await changeOf(params.changeId);
+    return { status: 200, body: await placementView(ctx.root, change) };
+  }).add("PUT", "/api/changes/{changeId}/placement", async ({ params, body }) => {
+    const change = await changeOf(params.changeId);
+    const b = api_exports.SavePlacementRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Send feature.yaml's text and the sha256 it started from.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const dir = changeFolder(ctx.root, change);
+    const file = join13(dir, FEATURE_FILE);
+    const was = await readFile11(file, "utf8").catch(() => void 0);
+    if (sha3(was ?? "") !== b.data.baseSha256)
+      throw conflict(`${FEATURE_FILE} changed since you opened it. Reload it, then edit again.`);
+    const lines = b.data.content.replace(/\r\n/g, "\n").split("\n");
+    const own = lines[0]?.startsWith(PLACED_HEAD) ? lines.slice(1) : lines;
+    let parsed;
+    try {
+      parsed = (0, import_yaml7.parse)(own.join("\n"));
+    } catch (e) {
+      throw new HttpError(422, "Not a placement", `${FEATURE_FILE} doesn't read as YAML: ${String(e.message ?? e).split("\n")[0]}`);
+    }
+    const p = FeaturePlacement.safeParse(parsed);
+    if (!p.success)
+      throw new HttpError(422, "Not a placement", `${FEATURE_FILE} doesn't read as a placement: ${p.error.issues.map((i) => `${i.path.join(".") || "(top)"}: ${i.message}`).join("; ")}`);
+    if (p.data.change !== change)
+      throw new HttpError(422, "Not a placement", `${FEATURE_FILE} names change ${p.data.change}, not ${change}.`);
+    const at = now().toISOString();
+    const head = `${PLACED_HEAD} Edited by ${ctx.user} on ${at}; review it in the feature PR.`;
+    const saved = `${head}
+${own.join("\n")}`;
+    await writeFileIfUnchanged(file, was, saved);
+    const md = renderFeature(p.data);
+    await writeFileAtomic(join13(dir, "feature.md"), md);
+    for (const [f, content] of [
+      [FEATURE_FILE, saved],
+      ["feature.md", md]
+    ])
+      await recordPersonSave(dir, change, { file: f, who: ctx.user, at, content }).catch(() => void 0);
+    const rel = `${changesRelOf(ctx.root)}/${change}`;
+    for (const f of [FEATURE_FILE, "feature.md"])
+      ctx.events.publish({ type: "file.changed", path: `${rel}/${f}` });
+    return { status: 200, body: await placementView(ctx.root, change) };
+  }).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) };
@@ -3926,12 +6101,13 @@ function uiStageRoutes(r, ctx, deps = {}) {
       comment: {
         question: q.id,
         text: q.answer.text,
-        by: q.answer.by,
+        by: answerByWords(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}"`,
+      commit: `git add ${written.files.join(" ")}
+git commit -m "${change}: a comment on ${f.finding.id}"`,
       next: v.next
     };
     return { status: 200, body: result };
@@ -3942,13 +6118,23 @@ function uiStageRoutes(r, ctx, deps = {}) {
 function catalogMayHaveChanged(root, path) {
   const p = path.replace(/^\.\/?/, "").replace(/\/+$/, "");
   const near = (dir) => {
-    const rel = relative3(root, dir).split(sep3).join("/");
+    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));
 }
+function extendUiRoutes(r, ctx, deps = {}, o = {}) {
+  const known = uiKnowRoutes(uiRunRoutes(uiRoutes(r, ctx, deps), ctx, deps), ctx, {
+    warm: o.warm === true
+  });
+  const base = uiInitiativeRoutes(known, ctx);
+  const views = uiGraphRoutes(uiAcrossRoutes(uiMeRoutes(base, ctx), ctx), ctx);
+  const specs = uiSpecRoutes(uiOnboardingRoutes(uiQuestionRoutes(views, ctx), ctx), ctx);
+  const all = uiComponentTypeRoutes(uiLinkMatchRoutes(uiSketchRoutes(uiDeclaredRoutes(uiOwnerRoutes(uiLinkRoutes(uiCopilotRunRoutes(uiStageRoutes(uiContractsRoutes(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), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx);
+  return uiDecisionRoutes(all, ctx);
+}
 async function startUi(root, o = {}, deps = {}) {
   const srv = await startServer({
     root,
@@ -3971,17 +6157,10 @@ async function startUi(root, o = {}, deps = {}) {
           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(uiFactsRoutes(uiTrustRoutes(uiCockpitRoutes(uiRepoRoutes(uiDocumentRoutes(uiAiRoutes(uiHistoryRoutes(uiModelRunRoutes(uiKnowledgeRoutes(uiCiteRoutes(specs, ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx), ctx);
-    }
+    extend: (r, ctx) => extendUiRoutes(r, ctx, deps, { warm: o.warm === true })
   });
   keepCatalogsInMemory(true);
-  void readCatalog(join12(catalogDirOf(root), "generated"), { cacheRoot: root }).catch(() => void 0);
+  void readCatalog(join14(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")
@@ -4005,7 +6184,7 @@ function openBrowser(url) {
   }
 }
 function untilStopped(embedded, stdin = process.stdin, o = {}) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve2) => {
     const alive = o.alive ?? ((pid) => {
       try {
         process.kill(pid, 0);
@@ -4028,7 +6207,7 @@ function untilStopped(embedded, stdin = process.stdin, o = {}) {
         stdin.off("close", stop);
         stdin.pause();
       }
-      resolve3();
+      resolve2();
     };
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
@@ -4074,12 +6253,14 @@ async function uiCommand(root, o, io) {
   if (o.open)
     openBrowser(srv.url);
   await untilStopped(o.embed === "vscode", process.stdin, o.parent !== void 0 ? { parent: o.parent } : {});
+  stopAllBuilds();
   await srv.close();
   io.out("Stopped.");
   return 0;
 }
 export {
   catalogMayHaveChanged,
+  extendUiRoutes,
   startUi,
   startedLines,
   uiCommand,