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

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

@@ -3,17 +3,14 @@ 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-U6GZSUMC.js";
 import {
   historyEntry,
   listHistory
-} from "./chunk-6AP2ZUUM.js";
+} from "./chunk-3WON4G3M.js";
+import "./chunk-JYTIHTIK.js";
 import {
-  uiFactsRoutes
-} from "./chunk-7S6VJ643.js";
+  uiComponentTypeRoutes
+} from "./chunk-CG6CULP6.js";
 import {
   answerAudit,
   auditLines,
@@ -21,38 +18,52 @@ import {
   precisionOf,
   prepareAudit,
   writeAudit
-} from "./chunk-CC5RNYZF.js";
-import "./chunk-BAT4CBB7.js";
-import "./chunk-5NLJH6R4.js";
-import "./chunk-QKMDT7VU.js";
-import "./chunk-4W7FOGAB.js";
+} from "./chunk-7FUIVIBG.js";
+import {
+  listRuns,
+  partStates,
+  runTranscript
+} from "./chunk-BA2HUMDN.js";
+import {
+  uiCiteRoutes
+} from "./chunk-WCEF7H6L.js";
+import {
+  isHandoffStep
+} from "./chunk-4Q3NN7VF.js";
 import {
   estimateOf
-} from "./chunk-NFKBU2UH.js";
+} from "./chunk-WFU77T3A.js";
+import {
+  changeMapBody,
+  changeMapOf,
+  targetFlowsOf
+} from "./chunk-GNWAOVFQ.js";
 import {
   changeArchive,
   changeHandoff,
   changeNew,
+  changeReleasePrs,
   changeSync
-} from "./chunk-JTYYEYRR.js";
+} from "./chunk-COYN3UAN.js";
 import {
-  uiCiteRoutes
-} from "./chunk-UTSFKZ72.js";
+  isSandbox,
+  learnCheck,
+  learnStart,
+  lessonsFor,
+  readProgress,
+  sandboxCreate
+} from "./chunk-ZQLRCA2V.js";
 import {
-  HttpError,
-  badRequest,
-  conflict,
-  notFound,
-  startServer,
-  strParam
-} from "./chunk-Q2X4IREC.js";
-import "./chunk-L336AJCZ.js";
+  defencesScan,
+  evalRun
+} from "./chunk-FVMPFCDS.js";
 import {
-  isHandoffStep
-} from "./chunk-4Q3NN7VF.js";
+  listReports,
+  readQuality
+} from "./chunk-FYBF5MB2.js";
 import {
   conformanceCommand
-} from "./chunk-CVZCW3NI.js";
+} from "./chunk-G5YJBNDZ.js";
 import {
   outcomeList,
   outcomeRecord,
@@ -61,162 +72,232 @@ import {
   releaseNotesCommand,
   releasePlanCommand,
   releaseSecurityCommand
-} from "./chunk-BJ5T3KDF.js";
+} from "./chunk-AZDITBCT.js";
 import {
-  changeMapBody,
-  changeMapOf
-} from "./chunk-VBSJ5NRB.js";
+  readServiceRequests
+} from "./chunk-36RY7ZXM.js";
+import {
+  runDone,
+  taskRun,
+  taskRunNotWaiting
+} from "./chunk-AOCWFA7T.js";
 import {
   executorsCheck,
   todoDone,
   todoRun,
   todoShow
-} from "./chunk-EDURU5DF.js";
+} from "./chunk-ZFQMMU5Y.js";
 import {
   inputsSha256,
   loadExecutors
-} from "./chunk-FF4IGX4Z.js";
+} from "./chunk-DDJPM5YX.js";
 import {
-  isSandbox,
-  learnCheck,
-  learnStart,
-  lessonsFor,
-  readProgress,
-  sandboxCreate
-} from "./chunk-2TTSX7NB.js";
+  initiativeStatus,
+  readView
+} from "./chunk-2V2ZPQQU.js";
 import {
-  defencesScan,
-  evalRun
-} from "./chunk-5MEN4SM5.js";
+  DecideError,
+  correctDecision,
+  decisionsView,
+  undoBatch
+} from "./chunk-UYLBRRFK.js";
 import {
-  listReports,
-  readQuality
-} from "./chunk-B3SWPNJF.js";
+  boxesOf,
+  candidatesOf,
+  uiLinkRoutes
+} from "./chunk-6DQYZU2W.js";
 import {
-  readServiceRequests
-} from "./chunk-YSEZQ6D3.js";
+  matchDone,
+  quotesOf,
+  readMatch,
+  runMatch
+} from "./chunk-QJCJOMW3.js";
+import "./chunk-3SSTNB4E.js";
+import "./chunk-JRVNXLZP.js";
 import {
-  initiativeStatus,
-  readView
-} from "./chunk-ILDGIXNH.js";
+  copilotAcpAllowed
+} from "./chunk-LIJJCBQI.js";
+import "./chunk-26Z7OGQW.js";
+import "./chunk-OKUB6RJA.js";
 import {
-  taskRun
-} from "./chunk-DYNC6BAQ.js";
-import "./chunk-GTW54D3D.js";
+  filesUnder,
+  memoByFiles,
+  recheckNow,
+  uiFactsRoutes
+} from "./chunk-QOOEYDNJ.js";
 import {
-  digestCommand
-} from "./chunk-UROTYIGJ.js";
+  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-OXOSJXOI.js";
+} from "./chunk-YZDZOEV4.js";
 import {
   sourcesAdd,
   sourcesSync
-} from "./chunk-7NYCH5HY.js";
+} from "./chunk-HXXP2NTE.js";
 import {
   INPUTS_SOURCE_ID
-} from "./chunk-SHEUEHKC.js";
-import "./chunk-WWPC2AZ2.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-X5WYPIH3.js";
+} from "./chunk-GK4PYVEC.js";
+import {
+  doctorChecks
+} from "./chunk-HGHRSF3E.js";
+import "./chunk-4B6BT75O.js";
 import {
   readMe,
   writeMe
-} from "./chunk-5ZV7BK22.js";
-import {
-  uiOnboardingRoutes
-} from "./chunk-R5MNPIMD.js";
+} from "./chunk-UF4UHCIG.js";
 import {
-  uiTrustRoutes
-} from "./chunk-2QMZOCWN.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 {
-  contractCheckOf,
-  estateJoinOnFile
-} from "./chunk-AZYBHPV4.js";
-import "./chunk-AB5E5HCN.js";
-import "./chunk-LGDW4G73.js";
+  checkoutOf
+} from "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
 import {
   intakeContext
-} from "./chunk-NGT5LLSE.js";
-import "./chunk-U6EPS5PF.js";
-import "./chunk-RUOGHYSK.js";
+} from "./chunk-TQ4TG57V.js";
+import {
+  workspaceOpen,
+  workspaceSync
+} from "./chunk-IFHDV6KQ.js";
+import "./chunk-LQH4P45K.js";
+import "./chunk-P2VBXX7N.js";
+import {
+  archiveGate,
+  ciArchiveGate
+} from "./chunk-ZX7235KR.js";
+import {
+  traceMatrix
+} from "./chunk-EZIN5E5B.js";
+import "./chunk-3LZ6P5EP.js";
 import {
   scanCommand
-} from "./chunk-WZRCGGXG.js";
-import "./chunk-IO6DQCZX.js";
+} from "./chunk-NCB6656Z.js";
+import "./chunk-TYD6I4CZ.js";
+import {
+  readChangeTasks,
+  readStory,
+  setTaskDone
+} from "./chunk-YWAKDNMH.js";
 import {
   catalogRecords,
   openChanges,
   systemGuide
-} from "./chunk-KLRZKW7Y.js";
-import {
-  doctorChecks
-} from "./chunk-Z7HYYDZM.js";
+} from "./chunk-FY3QIRTL.js";
 import "./chunk-3G4YI4ZU.js";
-import "./chunk-MFUFB3LN.js";
-import "./chunk-RTUUX7PX.js";
-import {
-  handoffDone,
-  workspaceOpen,
-  workspaceSync
-} from "./chunk-HMZQAIR5.js";
-import "./chunk-2T5CQH4R.js";
-import "./chunk-G5BYKJIM.js";
-import {
-  readChangeTasks,
-  readStory
-} from "./chunk-2ZICHO3V.js";
+import "./chunk-2HTEMYTB.js";
 import {
   ASSISTANT_FORMATS,
   readProbes,
   whatRunsWhere
-} from "./chunk-BAXM3JFQ.js";
+} from "./chunk-3AQ2R5NL.js";
 import {
   critic,
   criticStats,
   findingAction
-} from "./chunk-IFV6MKYV.js";
-import "./chunk-CDLTRJ4N.js";
+} from "./chunk-PTQ3ZALZ.js";
+import "./chunk-A2G72UI4.js";
 import {
   planStories,
   snowDraft,
   snowSubmit
-} from "./chunk-7S7OFVIU.js";
-import "./chunk-MIZNACDI.js";
-import {
-  archiveGate,
-  ciArchiveGate
-} from "./chunk-ESP3RUUR.js";
-import {
-  traceMatrix
-} from "./chunk-YC2K3FJG.js";
-import "./chunk-TAKAEJRD.js";
+} 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-XO5RQKNM.js";
+  stageGate,
+  writeSketch
+} from "./chunk-BEPCKDCP.js";
 import {
+  FeaturePlacement,
+  STAGES,
   STAGE_PHASE,
   fieldNames,
   rerunOf
-} from "./chunk-L3T33FA7.js";
+} from "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
 import "./chunk-VOGCSYOI.js";
 import {
   layerRules,
@@ -230,8 +311,9 @@ import {
   readStoryIndex,
   reviewedGates,
   roundsOf
-} from "./chunk-VEJYZEPC.js";
+} from "./chunk-K332XW7K.js";
 import {
+  ChangeOwnersError,
   artifactFiles,
   artifactPhase,
   changeFolder,
@@ -241,24 +323,27 @@ import {
   detectConflicts,
   liveHandoff,
   loadChangeContext,
-  requiredArtifacts
-} from "./chunk-IOW6BF3U.js";
-import "./chunk-43E6XX67.js";
+  requiredArtifacts,
+  setChangeOwners
+} from "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
 import {
   fileStepStore,
   manualAdapter,
   stepOfProvisional
-} from "./chunk-V3UEPUHT.js";
+} from "./chunk-4KNOJC6J.js";
 import {
   componentRenames,
   estateFacts,
+  estateRepos,
   forgetCatalogs,
   hostAliases,
   joinReposOf,
   keepCatalogsInMemory,
   outsideProfileSystems,
-  readCatalog
-} from "./chunk-EZBAS5BL.js";
+  readCatalog,
+  targetPicker
+} from "./chunk-4SLBCEPD.js";
 import {
   OrgPackProposal,
   SNAPSHOT_FILE,
@@ -282,67 +367,86 @@ import {
   snapshotDates,
   snapshotSources,
   writeReview
-} from "./chunk-KCQS52TH.js";
+} from "./chunk-64AADMTW.js";
 import {
   NoSuchNode,
   buildEstate,
   focusView,
   nodeView,
   viewKey
-} from "./chunk-IPSFMTK2.js";
+} from "./chunk-JYMIB5XY.js";
 import {
   readServiceRequestExports,
   readVendorSpec,
   readWorkItemExports
-} from "./chunk-TNCROWPQ.js";
-import "./chunk-7IM4BVVH.js";
-import "./chunk-RBXDHCN7.js";
-import "./chunk-YXUIUOQZ.js";
-import "./chunk-S5PSGAQ2.js";
-import "./chunk-CYX36GKZ.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-ZQC7MNQB.js";
-import "./chunk-TLDL2ZZI.js";
+} from "./chunk-XOL3GFW2.js";
 import {
   COMMON_SETTINGS,
   PROVIDER_SETTINGS,
   defaultKeyStore,
   looksLikeKey
-} from "./chunk-FF4ZMLSL.js";
+} from "./chunk-PRW3HXM3.js";
 import {
   providerFactoryFor
-} from "./chunk-QNMLLYTN.js";
+} from "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
 import {
   ASSISTANTS,
   ChangeArtifact,
   DEFAULT_PORT,
   DEFAULT_RUNTIME,
+  DeclareError,
   DiagramLayout,
   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,
+  copilotAcpOf,
+  currentSignal,
+  decideOf,
+  declareLink,
+  declaredOf,
+  diagramsRelOf,
+  eolOf,
   external_exports,
   factIdPart,
+  factsDirOf,
   factsRelOf,
   gateRoundLimit,
+  inEol,
   inputsDirOf,
+  isAdopted,
   joinConventions,
   joinSharedMaps,
   joinVendorOperations,
@@ -350,10 +454,13 @@ import {
   knowledgeKindOf,
   knowledgeRelOf,
   layoutPath,
+  lfOnly,
   listQuestions,
   loadOrgPack,
+  manifestFiles,
   orgPackDirOf,
   pageStanding,
+  parseCorrections,
   proposalsDirOf,
   proposalsRelOf,
   readEstateJoins,
@@ -363,20 +470,25 @@ import {
   require_dist,
   runsDirOf,
   runsRelOf,
+  setManifestField,
+  specDirOf,
   specRelOf,
-  specRepos
-} from "./chunk-YK6CSODO.js";
+  specRepos,
+  undeclareLink
+} from "./chunk-PAINMSID.js";
 import {
+  FileChangedError,
   createLog,
-  writeFileAtomic
-} from "./chunk-MMB2OHUY.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 join11, relative as relative2, sep as sep2 } 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";
@@ -388,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 = [];
@@ -440,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;
@@ -459,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
     });
   }
@@ -473,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: {
@@ -483,6 +637,74 @@ 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 text = await readFile(join2(dir, "run.json"), "utf8").catch(() => void 0);
@@ -490,6 +712,7 @@ async function runView(root, change, runId) {
     return void 0;
   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,
@@ -506,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) {
@@ -519,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, {
@@ -557,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 {
@@ -581,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: {
@@ -594,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}`
@@ -618,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);
@@ -644,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-U542BJME.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-2TG2QGKW.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-GXDATVSY.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 ?? "", {
@@ -700,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));
@@ -759,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 };
@@ -867,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 = [];
@@ -925,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 {
@@ -936,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;
 }
@@ -998,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([])
 });
@@ -1006,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) => {
@@ -1028,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)
@@ -1079,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();
@@ -1153,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();
@@ -1226,6 +1893,38 @@ 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("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();
@@ -1320,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 }) => {
@@ -1497,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 {
@@ -1513,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;
@@ -1524,7 +2223,7 @@ function uiRunRoutes(r, ctx, deps = {}) {
       body: {
         sandbox,
         roles,
-        lessons: view2,
+        lessons: view3,
         ...cur ? {
           current: {
             lesson: cur.id,
@@ -1564,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);
@@ -1736,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;
       });
     }
@@ -1747,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}.`);
@@ -1756,7 +2456,7 @@ 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-F4D4G2A6.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 });
@@ -1773,6 +2473,12 @@ function uiKnowRoutes(r, ctx, o = {}) {
     } 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);
@@ -1780,7 +2486,7 @@ function uiKnowRoutes(r, ctx, o = {}) {
     return { status: 200, body: { code, data: body, problems: err } };
   };
   const text = async (args) => {
-    const { main } = await import("./chunk-F4D4G2A6.js");
+    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 });
@@ -1798,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-3GLDB4IT.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) });
@@ -1882,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
@@ -1895,16 +2690,79 @@ function uiQuestionRoutes(r, ctx, deps = {}) {
     const mine = strParam(query, "mine");
     if (mine !== void 0 && mine !== "true")
       throw badRequest("mine is true, or left out.");
-    const listed = await listQuestions(ctx.root, state ? { state } : {});
-    const { routeQuestions } = await import("./chunk-MRCETHW5.js");
-    const routed = await routeQuestions(ctx.root, listed.questions, mine ? { mine: ctx.user } : {});
+    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 } : {}
+      ...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.`);
@@ -1918,13 +2776,13 @@ function uiQuestionRoutes(r, ctx, deps = {}) {
       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-VIRTPODJ.js");
+    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-PHJOOL6U.js");
+    const { evidenceExcerpts } = await import("./chunk-UFE36WJH.js");
     return {
       status: 200,
       body: {
@@ -1947,7 +2805,7 @@ function uiQuestionRoutes(r, ctx, deps = {}) {
         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-VIRTPODJ.js");
+        const { targetAnswerOf, offerLine } = await import("./chunk-IFFRGC3N.js");
         const t = await targetAnswerOf(ctx.root, q0, target, {
           ...addSystem ? { addSystem } : {},
           ...name ? { name } : {}
@@ -2018,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({
@@ -2113,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;
 }
@@ -2205,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 {
@@ -2224,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)
@@ -2245,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();
@@ -2261,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")
@@ -2289,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)
@@ -2435,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);
   };
@@ -2459,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-QWSLMVHI.js");
+    const { conformanceOf } = await import("./chunk-FRHD22WM.js");
     const c = await conformanceOf(root, change);
     if (!c)
       throw notFound(`There is no change ${change}.`);
@@ -2474,7 +3403,7 @@ function uiSpecRoutes(r, ctx) {
   });
   r.add("GET", "/api/changes/{changeId}/impact", async ({ params }) => {
     const change = idOf2(params.changeId, "change");
-    const { changeImpactOf } = await import("./chunk-4REDBQOZ.js");
+    const { changeImpactOf } = await import("./chunk-2D7PWSOK.js");
     const i = await changeImpactOf(root, change);
     if (!i)
       throw notFound(`There is no change ${change}.`);
@@ -2508,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-]*$/;
@@ -2579,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 = [];
@@ -2670,7 +3599,7 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
     const platforms = [];
     for (const { platform } of op.profiles) {
       const text = await readFile4(join6(proposalsDirOf(root), "orgpack", `${platform}.yaml`), "utf8").catch(() => void 0);
-      const data = text === void 0 ? void 0 : (0, import_yaml3.parse)(text);
+      const 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] : [];
@@ -2702,7 +3631,7 @@ function uiKnowledgeRoutes(r, ctx, deps = {}) {
       if (date) {
         const file = join6(knowledgeDirOf(root), "snapshots", w.id, date, SNAPSHOT_FILE);
         const text = await readFile4(file, "utf8").catch(() => void 0);
-        const m = text === void 0 ? void 0 : SnapshotManifest.safeParse((0, import_yaml3.parse)(text));
+        const m = text === void 0 ? void 0 : SnapshotManifest.safeParse((0, import_yaml4.parse)(text));
         if (m?.success)
           snapshot = {
             date,
@@ -2942,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] } : {}
     });
@@ -2951,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}`
@@ -3016,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 }) => {
@@ -3054,7 +3984,7 @@ 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;
 }
@@ -3064,7 +3994,7 @@ async function configuredModel(root) {
     return null;
   let y;
   try {
-    y = (0, import_yaml4.parse)(text);
+    y = (0, import_yaml5.parse)(text);
   } catch {
     return null;
   }
@@ -3080,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-F4D4G2A6.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));
@@ -3140,6 +4073,900 @@ 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-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: [] }]
+    };
+  }
+  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 };
+  }
+}
+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();
+  };
+  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: {
+        run: view3,
+        allowed: a.allowed,
+        ...a.allowed ? {} : { why: NOT_ALLOWED },
+        ...a.model ? { model: a.model } : {}
+      }
+    };
+  }).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;
+    }
+    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) {
@@ -3172,18 +4999,18 @@ function uiHistoryRoutes(r, ctx) {
 }
 
 // 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 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"];
+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 = () => join8(orgPackDirOf(root), "runtime.yaml");
+  const file = () => join10(orgPackDirOf(root), "runtime.yaml");
   const rel = () => relative(root, file()).split(sep).join("/");
   const build = async (op, type, settings) => {
     if (deps.provider)
@@ -3231,13 +5058,16 @@ function uiAiRoutes(r, ctx, deps = {}) {
         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 = existsSync(file()) ? await readFile6(file(), "utf8") : void 0;
-    const raw = text !== void 0 ? (0, import_yaml5.parse)(text) ?? {} : structuredClone(DEFAULT_RUNTIME);
+    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];
@@ -3258,18 +5088,39 @@ function uiAiRoutes(r, ctx, deps = {}) {
       }
       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 header = (text ?? "").split(/\r?\n/).filter((l, i, a) => a.slice(0, i + 1).every((x) => x.startsWith("#")));
-    await writeFileAtomic(file(), `${header.length ? `${header.join("\n")}
-` : ""}${(0, import_yaml5.stringify)(raw, { lineWidth: 0 })}`);
+    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 }) => {
@@ -3316,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-IHRP4OYV.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 ?? {});
@@ -3325,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-3GLDB4IT.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 ?? "", {
@@ -3335,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-GXDATVSY.js");
+    const { AttachError, promoteChangeInput } = await import("./chunk-XQ3YZ4QW.js");
     try {
       const res = await promoteChangeInput(root, params.changeId, params.name);
       changed(res.path);
@@ -3352,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-U6TD7UOH.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-U6TD7UOH.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.`);
@@ -3367,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-U6TD7UOH.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 });
@@ -3380,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-U6TD7UOH.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 });
@@ -3401,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;
     }
   });
@@ -3410,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-RONDYDMQ.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")
@@ -3422,7 +5315,7 @@ function uiCockpitRoutes(r, ctx) {
       throw e;
     }
   }).add("GET", "/api/past-changes", async ({ query }) => {
-    const { changeAboutText, similarChanges } = await import("./chunk-63565QTF.js");
+    const { changeAboutText, similarChanges } = await import("./chunk-BC6KKZ67.js");
     const change = query.get("change");
     const text = change ? await changeAboutText(ctx.root, change) : query.get("text")?.trim();
     if (change && !text)
@@ -3440,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-63565QTF.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-GXDATVSY.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}` });
@@ -3461,9 +5354,9 @@ function uiCockpitRoutes(r, ctx) {
 }
 
 // packages/cli/dist/ui-api-audit.js
-var REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+var REPO3 = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
 var repoOf = (v) => {
-  if (!REPO.test(v))
+  if (!REPO3.test(v))
     throw badRequest(`${JSON.stringify(v)} isn't a repo name.`);
   return v;
 };
@@ -3557,15 +5450,16 @@ function uiAuditRoutes(r, ctx, deps = {}) {
       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"`
+      commit: `git add ${p.fileRel}
+git commit -m "${repo}: a person's sample audit answers"`
     };
     return { status: 200, body: result };
   });
 }
 
 // packages/cli/dist/ui-api-outside.js
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+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) => [
@@ -3577,12 +5471,13 @@ 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);
+  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: [] };
@@ -3593,7 +5488,7 @@ async function outsideView(root) {
     const system = systems.find((s) => s.id === d.systems[0]);
     if (!system || specs.has(system.id))
       continue;
-    const body = await readFile7(join9(inputsDirOf(root), ...d.path.split("/").slice(1)), "utf8");
+    const 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);
@@ -3625,7 +5520,7 @@ async function outsideView(root) {
     ...joinConventions(op)
   }) : { matches: [], gaps: [], asks: [] };
   const contracts = await contractCheckOf(root).catch(() => void 0);
-  const catalog = records.length ? records : (await readCatalog(join9(catalogDirOf(root), "generated"), { cacheRoot: root })).records;
+  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,
@@ -3783,9 +5678,196 @@ function uiContractsRoutes(r, ctx, o = {}) {
 }
 
 // packages/cli/dist/ui-api-stages.js
-import { stat as stat4 } from "node:fs/promises";
-import { join as join10 } from "node:path";
-var ID2 = /^[a-z0-9][a-z0-9._-]{0,99}$/;
+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 slashOf = (stage, change) => `/atticus-${stage === "small" ? "small" : stage} ${change}`;
+var nextOf = (stage, change) => ({
+  stage,
+  command: rerunOf(stage, change),
+  slash: slashOf(stage, change)
+});
+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;
+}
+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 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 {
+    change,
+    page,
+    files,
+    corrections: mine.map(view),
+    next: nextOf(waiting?.stage ?? PAGE_STAGE[page], change),
+    problems
+  };
+}
+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 uiDraftRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  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 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 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()
+    }).catch(refusal);
+    const written = `${changesRelOf(ctx.root)}/${change}/${CORRECTIONS_FILE}`;
+    ctx.events.publish({ type: "file.changed", path: written });
+    const result = {
+      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
+var ID4 = /^[a-z0-9][a-z0-9._-]{0,99}$/;
 function findingOptions(f) {
   const open = f.state === "open";
   const issue = f.kind === "issue";
@@ -3797,8 +5879,8 @@ function findingOptions(f) {
     ...open && f.question ? { ask: { text: f.question.text, owner: f.question.owner } } : {}
   };
 }
-var exists2 = (p) => stat4(p).then(() => true, () => false);
-var slashOf = (stage, change) => `/atticus-${stage} ${change}`;
+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;
@@ -3824,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,
@@ -3848,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,
@@ -3881,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)
@@ -3894,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(join10(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) };
@@ -3948,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 };
@@ -3971,6 +6125,16 @@ function catalogMayHaveChanged(root, path) {
   };
   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,
@@ -3993,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(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);
-    }
+    extend: (r, ctx) => extendUiRoutes(r, ctx, deps, { warm: o.warm === true })
   });
   keepCatalogsInMemory(true);
-  void readCatalog(join11(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")
@@ -4096,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,