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

package/dist/{chunk-2RMYG36Q.js → chunk-C3RY6KU6.js}

@@ -4,30 +4,27 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
-  catalogRecords
-} from "./chunk-B2WLAWNJ.js";
+  QueryError,
+  askLookup,
+  graph,
+  impact,
+  openIndex,
+  translate
+} from "./chunk-ISUAAMGS.js";
 import {
   readRound,
   reviewedGates,
   roundsOf
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-S4PMJU6H.js";
 import {
   changeFolder,
   changeStore
-} from "./chunk-XY3P7JW7.js";
-import {
-  QueryError,
-  askLookup,
-  graph,
-  impact,
-  openIndex,
-  translate
-} from "./chunk-T6AIP7H5.js";
+} from "./chunk-IDKCWSM5.js";
 import {
   baseClonePath,
   gitUser,
   loadRepos
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   API_VERSION,
   DEFAULT_PORT,
@@ -35,8 +32,8 @@ import {
   RECORD_KINDS,
   RecordId,
   Severity,
+  api_exports,
   catalogDirOf,
-  changesDirOf,
   factsDirOf,
   fastPathOf,
   inputsDirOf,
@@ -48,23 +45,14 @@ import {
   proposalsDirOf,
   questionOfLens,
   questionsDirOf,
-  readRepoSpec,
-  require_dist,
   runsDirOf,
-  specRepos,
   specsDirOf,
   withSignal
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 import {
+  FileChangedError,
   SCHEMA_VERSION
-} from "./chunk-D3PO4DOZ.js";
-import {
-  __toESM
-} from "./chunk-TV45EUGM.js";
-
-// packages/cli/dist/ui-api-cites.js
-import { readdir, readFile as readFile3, stat as stat3 } from "node:fs/promises";
-import { isAbsolute, join as join4, relative as relative2, sep as sep3 } from "node:path";
+} from "./chunk-TUULXQRW.js";
 
 // packages/server/dist/http.js
 var HttpError = class extends Error {
@@ -148,6 +136,115 @@ function intParam(q, name, min, max) {
 }
 var strParam = (q, name) => q.get(name) || void 0;
 
+// packages/server/dist/server.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { createServer } from "node:http";
+
+// packages/server/dist/jobs.js
+var JobManager = class {
+  publish;
+  now;
+  jobs = /* @__PURE__ */ new Map();
+  cancelledIds = /* @__PURE__ */ new Set();
+  aborts = /* @__PURE__ */ new Map();
+  seq = 0;
+  /** Round 41: every running job of a kind, in start order (a later one never hides an earlier). */
+  running = /* @__PURE__ */ new Map();
+  constructor(publish, now = () => /* @__PURE__ */ new Date()) {
+    this.publish = publish;
+    this.now = now;
+  }
+  /**
+   * A running job of a kind, if any: the earliest still running (one scan at a time: a second
+   * ask gets 409).
+   */
+  runningOf(kind) {
+    for (const id of this.running.get(kind) ?? []) {
+      const j = this.jobs.get(id);
+      if (j?.state === "running")
+        return j;
+    }
+    return void 0;
+  }
+  get(id) {
+    return this.jobs.get(id);
+  }
+  start(kind, work) {
+    const id = `job-${++this.seq}`;
+    const job = {
+      id,
+      kind,
+      state: "running",
+      progress: { done: 0, total: 0, message: "Starting" },
+      startedAt: this.now().toISOString(),
+      errors: []
+    };
+    this.jobs.set(id, job);
+    const ofKind = this.running.get(kind) ?? /* @__PURE__ */ new Set();
+    ofKind.add(id);
+    this.running.set(kind, ofKind);
+    const abort = new AbortController();
+    this.aborts.set(id, abort);
+    const cancelled = this.cancelledIds;
+    const control = {
+      progress: (done, total, message) => {
+        job.progress = { done, total, message };
+        this.publish({ type: "job.progress", jobId: id, done, total, message });
+      },
+      get cancelled() {
+        return cancelled.has(id);
+      }
+    };
+    void (async () => {
+      try {
+        const out = await withSignal(abort.signal, () => work(control));
+        if (out?.result)
+          job.result = out.result;
+        if (out?.errors?.length)
+          job.errors.push(...out.errors);
+        job.state = this.cancelledIds.has(id) ? "cancelled" : job.errors.length ? "failed" : "done";
+      } catch (e) {
+        if (this.cancelledIds.has(id))
+          job.state = "cancelled";
+        else {
+          job.errors.push(e instanceof Error ? e.message : String(e));
+          job.state = "failed";
+        }
+      }
+      this.aborts.delete(id);
+      job.finishedAt = this.now().toISOString();
+      ofKind.delete(id);
+      if (!ofKind.size && this.running.get(kind) === ofKind)
+        this.running.delete(kind);
+      this.publish({ type: "job.done", jobId: id, state: job.state });
+    })();
+    return job;
+  }
+  /** Ask a running job to stop; false when it already finished. */
+  cancel(id) {
+    const j = this.jobs.get(id);
+    if (!j || j.state !== "running")
+      return false;
+    this.cancelledIds.add(id);
+    this.aborts.get(id)?.abort();
+    return true;
+  }
+  /** Wait for a job to finish (tests and the CLI). */
+  async settle(id, timeoutMs = 6e4) {
+    const start = Date.now();
+    for (; ; ) {
+      const j = this.jobs.get(id);
+      if (!j)
+        throw new Error(`No job ${id}`);
+      if (j.state !== "running" && j.state !== "queued")
+        return j;
+      if (Date.now() - start > timeoutMs)
+        throw new Error(`Job ${id} did not finish`);
+      await new Promise((r) => setTimeout(r, 20));
+    }
+  }
+};
+
 // packages/server/dist/routes.js
 import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
@@ -232,6 +329,7 @@ function apiRoutes(r, ctx) {
       ...strParam(query, "status") ? { status: strParam(query, "status") } : {},
       ...strParam(query, "system") ? { system: strParam(query, "system") } : {},
       ...strParam(query, "q") ? { q: strParam(query, "q") } : {},
+      ...strParam(query, "confidence") ? { confidence: strParam(query, "confidence") } : {},
       ...strParam(query, "cursor") ? { cursor: strParam(query, "cursor") } : {},
       ...limit !== void 0 ? { limit } : {}
     };
@@ -289,7 +387,20 @@ function apiRoutes(r, ctx) {
     return { status: 200, body: await withIndex(root, (ix) => graph(ix, o)) };
   }).add("GET", "/api/impact/{id}", async ({ params, query }) => {
     const depth = intParam(query, "depth", 1, 10);
-    const res = await withIndex(root, (ix) => impact(ix, params.id, depth));
+    const res = await withIndex(root, (ix) => {
+      const r2 = impact(ix, params.id, depth);
+      if (!r2)
+        return void 0;
+      return {
+        ...r2,
+        affected: r2.affected.map((a) => {
+          const rec = ix.find(a.id)[0];
+          const ai = (rec?.evidence ?? []).find((e) => e.source === "ai");
+          const flagged = Array.isArray(rec?.flags) && rec.flags.includes("joined-by-ai");
+          return flagged || ai ? { ...a, byAi: true, ...ai?.run ? { run: ai.run } : {} } : a;
+        })
+      };
+    });
     if (!res)
       throw notFound(`There is no record ${params.id} in the catalog.`);
     return { status: 200, body: res };
@@ -380,6 +491,8 @@ function apiRoutes(r, ctx) {
     return { status: 200, body };
   }).add("GET", "/api/findings", async ({ query }) => {
     const change = strParam(query, "change");
+    if (change !== void 0 && !RecordId.safeParse(change).success)
+      throw badRequest(`${change} isn't a change id.`);
     const gate = strParam(query, "gate");
     const state = strParam(query, "state");
     const lens = enumParam(query, "lens", Lens.options);
@@ -393,6 +506,8 @@ function apiRoutes(r, ctx) {
           body.push(f);
     return { status: 200, body };
   }).add("GET", "/api/findings/{changeId}/{findingId}", async ({ params }) => {
+    if (!RecordId.safeParse(params.changeId).success)
+      throw badRequest(`${params.changeId} isn't a change id.`);
     const f = (await latestFindings(root, params.changeId)).find((x) => x.id === params.findingId);
     if (!f)
       throw notFound(`Change ${params.changeId} has no finding ${params.findingId}.`);
@@ -435,107 +550,9 @@ function apiRoutes(r, ctx) {
   });
 }
 
-// packages/server/dist/server.js
-import { randomBytes, timingSafeEqual } from "node:crypto";
-import { createServer } from "node:http";
-
-// packages/server/dist/jobs.js
-var JobManager = class {
-  publish;
-  now;
-  jobs = /* @__PURE__ */ new Map();
-  cancelledIds = /* @__PURE__ */ new Set();
-  aborts = /* @__PURE__ */ new Map();
-  seq = 0;
-  running = /* @__PURE__ */ new Map();
-  constructor(publish, now = () => /* @__PURE__ */ new Date()) {
-    this.publish = publish;
-    this.now = now;
-  }
-  /** The running job of a kind, if any (one scan at a time: a second asks gets 409). */
-  runningOf(kind) {
-    const id = this.running.get(kind);
-    return id ? this.jobs.get(id) : void 0;
-  }
-  get(id) {
-    return this.jobs.get(id);
-  }
-  start(kind, work) {
-    const id = `job-${++this.seq}`;
-    const job = {
-      id,
-      kind,
-      state: "running",
-      progress: { done: 0, total: 0, message: "Starting" },
-      startedAt: this.now().toISOString(),
-      errors: []
-    };
-    this.jobs.set(id, job);
-    this.running.set(kind, id);
-    const abort = new AbortController();
-    this.aborts.set(id, abort);
-    const cancelled = this.cancelledIds;
-    const control = {
-      progress: (done, total, message) => {
-        job.progress = { done, total, message };
-        this.publish({ type: "job.progress", jobId: id, done, total, message });
-      },
-      get cancelled() {
-        return cancelled.has(id);
-      }
-    };
-    void (async () => {
-      try {
-        const out = await withSignal(abort.signal, () => work(control));
-        if (out?.result)
-          job.result = out.result;
-        if (out?.errors?.length)
-          job.errors.push(...out.errors);
-        job.state = this.cancelledIds.has(id) ? "cancelled" : job.errors.length ? "failed" : "done";
-      } catch (e) {
-        if (this.cancelledIds.has(id))
-          job.state = "cancelled";
-        else {
-          job.errors.push(e instanceof Error ? e.message : String(e));
-          job.state = "failed";
-        }
-      }
-      this.aborts.delete(id);
-      job.finishedAt = this.now().toISOString();
-      if (this.running.get(kind) === id)
-        this.running.delete(kind);
-      this.publish({ type: "job.done", jobId: id, state: job.state });
-    })();
-    return job;
-  }
-  /** Ask a running job to stop; false when it already finished. */
-  cancel(id) {
-    const j = this.jobs.get(id);
-    if (!j || j.state !== "running")
-      return false;
-    this.cancelledIds.add(id);
-    this.aborts.get(id)?.abort();
-    return true;
-  }
-  /** Wait for a job to finish (tests and the CLI). */
-  async settle(id, timeoutMs = 6e4) {
-    const start = Date.now();
-    for (; ; ) {
-      const j = this.jobs.get(id);
-      if (!j)
-        throw new Error(`No job ${id}`);
-      if (j.state !== "running" && j.state !== "queued")
-        return j;
-      if (Date.now() - start > timeoutMs)
-        throw new Error(`Job ${id} did not finish`);
-      await new Promise((r) => setTimeout(r, 20));
-    }
-  }
-};
-
 // packages/server/dist/static.js
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { extname, join as join2, normalize, sep } from "node:path";
+import { extname, join as join2, normalize, resolve, sep } from "node:path";
 var TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -564,7 +581,8 @@ function appCsp(port, embed) {
   ].join("; ");
 }
 var escapeAttr = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
-async function staticFile(dir, path, token) {
+async function staticFile(givenDir, path, token, pageKey) {
+  const dir = resolve(givenDir);
   let rel;
   try {
     rel = decodeURIComponent(path);
@@ -583,7 +601,12 @@ async function staticFile(dir, path, token) {
   const ext = extname(target).toLowerCase();
   const type = TYPES[ext] ?? "application/octet-stream";
   if (ext === ".html") {
-    const html = (await readFile2(target, "utf8")).replace(/<meta name="atticus-token" content="[^"]*"\s*\/?>/, `<meta name="atticus-token" content="${escapeAttr(token)}" />`);
+    const tokenMeta = `<meta name="atticus-token" content="${escapeAttr(token)}" />`;
+    const keyMeta = pageKey === void 0 ? "" : `<meta name="atticus-page-key" content="${escapeAttr(pageKey)}" />`;
+    let html = (await readFile2(target, "utf8")).replace(/<meta name="atticus-token" content="[^"]*"\s*\/?>/, () => tokenMeta);
+    if (keyMeta)
+      html = /<meta name="atticus-page-key" content="[^"]*"\s*\/?>/.test(html) ? html.replace(/<meta name="atticus-page-key" content="[^"]*"\s*\/?>/, () => keyMeta) : html.replace(tokenMeta, () => `${tokenMeta}
+    ${keyMeta}`);
     return { status: 200, type, body: html, cache: "no-store" };
   }
   return {
@@ -595,6 +618,91 @@ async function staticFile(dir, path, token) {
   };
 }
 
+// packages/server/dist/confirm.js
+import { randomBytes, timingSafeEqual } from "node:crypto";
+var CONFIRM_TTL_MS = 12e4;
+var MAX_OPEN = 256;
+var Confirmations = class {
+  now;
+  open = /* @__PURE__ */ new Map();
+  constructor(now = () => Date.now()) {
+    this.now = now;
+  }
+  issue(write, target) {
+    const t = this.now();
+    for (const [k, v] of this.open)
+      if (v.until < t)
+        this.open.delete(k);
+    while (this.open.size >= MAX_OPEN)
+      this.open.delete(this.open.keys().next().value);
+    const confirmation = randomBytes(32).toString("base64url");
+    const until = t + CONFIRM_TTL_MS;
+    this.open.set(confirmation, { write, target, until });
+    return { confirmation, write, target, expiresAt: new Date(until).toISOString() };
+  }
+  /**
+   * Whether `given` confirms this write of this target now. It is spent whatever the answer, so a
+   * confirmation is never tried twice: a replay, another target or another write is refused.
+   */
+  take(write, target, given) {
+    if (typeof given !== "string" || !given)
+      return false;
+    const c = this.open.get(given);
+    if (!c)
+      return false;
+    this.open.delete(given);
+    return c.write === write && c.target === target && this.now() <= c.until;
+  }
+};
+function sameSecret(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+var WITHOUT_THE_APP = {
+  handoff: {
+    what: "Raising a hand-off opens a PR",
+    cli: "atticus change handoff <change> --approve"
+  },
+  "release-prs": {
+    what: "Raising the release PRs pushes the change branch and opens PRs",
+    cli: "atticus change release-prs <change> --approve"
+  },
+  merge: { what: "Merging a ready PR", cli: "atticus change sync <change> --approve" },
+  "task-pr": {
+    what: "Raising a task's PR pushes its branch and opens a PR",
+    cli: "atticus task run <change> <task> --level pr --approve"
+  },
+  "digest-send": {
+    what: "Sending the digest posts a message",
+    cli: "atticus digest --send"
+  },
+  propose: {
+    what: "Propose for review pushes a branch and opens a PR",
+    cli: "git commit, push and open the PR yourself"
+  },
+  "step-run": {
+    what: "Running a step with a team's tool acts on their systems",
+    cli: "atticus todo run <step> --with <executor> --approve <you> --inputs <sha-256>"
+  },
+  "ai-model": {
+    what: "Changing where runtime.yaml sends the model's key (its provider, keyEnv or address)",
+    cli: "edit runtime.yaml yourself and propose it for review"
+  },
+  "ai-test": {
+    what: "Testing model settings that aren't committed sends the key to them",
+    cli: "commit runtime.yaml first, or run the step from the command line"
+  }
+};
+function needsConfirmation(write) {
+  const w = WITHOUT_THE_APP[write];
+  return new HttpError(403, "This needs a person's confirmation", `${w.what}, which a person confirms: click it in the Atticus app, or run ${w.cli} in a terminal. The session token alone (atticus ui --show-token, for assistants and scripts) never approves a write to a shared system (ADR 0186).`, { confirm: write });
+}
+function requireConfirmation(c, write, target, given) {
+  if (!c.take(write, target, given))
+    throw needsConfirmation(write);
+}
+
 // packages/server/dist/watch.js
 import { statSync, watch } from "node:fs";
 import { join as join3, relative, sep as sep2 } from "node:path";
@@ -613,6 +721,14 @@ function watchMetarepo(o) {
   const delay = o.delayMs ?? 300;
   const maxPaths = o.maxPaths ?? 50;
   const watchers = /* @__PURE__ */ new Map();
+  const inodes = /* @__PURE__ */ new Map();
+  const inodeOf = (d) => {
+    try {
+      return statSync(d).ino;
+    } catch {
+      return void 0;
+    }
+  };
   const problems = [];
   const pending = /* @__PURE__ */ new Set();
   let timer;
@@ -673,21 +789,39 @@ function watchMetarepo(o) {
         note(name ? join3(dir, String(name)) : dir);
       });
       w.on("error", (e) => {
-        problems.push(`${posix(relative(root, dir)) || "."}: ${e.message}`);
         w.close();
+        if (watchers.get(dir) !== w)
+          return;
+        problems.push(`${posix(relative(root, dir)) || "."}: ${e.message}`);
         watchers.delete(dir);
+        inodes.delete(dir);
       });
       watchers.set(dir, w);
+      const ino = inodeOf(dir);
+      if (ino !== void 0)
+        inodes.set(dir, ino);
+      const label = `${posix(relative(root, dir)) || "."}: `;
+      for (let i = problems.length - 1; i >= 0; i--)
+        if (problems[i].startsWith(label))
+          problems.splice(i, 1);
     } catch (e) {
       problems.push(`${posix(relative(root, dir)) || "."}: ${e.message}`);
     }
   };
   const attach = () => {
+    for (const [d, w] of watchers) {
+      const ino = inodeOf(d);
+      if (ino === void 0 || inodes.has(d) && inodes.get(d) !== ino) {
+        w.close();
+        watchers.delete(d);
+        inodes.delete(d);
+      }
+    }
+    follow(root, false);
+    follow(join3(root, ".atticus"), false);
     for (const d of folders())
       follow(d, true);
   };
-  follow(root, false);
-  follow(join3(root, ".atticus"), false);
   attach();
   return {
     get following() {
@@ -707,6 +841,8 @@ function watchMetarepo(o) {
 
 // packages/server/dist/ws.js
 import { createHash } from "node:crypto";
+var MAX_CLIENT_FRAME = 64 * 1024;
+var MAX_CLIENT_BUFFER = 256 * 1024;
 var GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 function acceptKey(key) {
   return createHash("sha1").update(key + GUID).digest("base64");
@@ -758,8 +894,14 @@ var Socket = class {
     this.closed = true;
     this.onClose(this);
   }
-  /** Client frames are masked; only control frames matter to us. */
+  /**
+   * Client frames are masked; only control frames matter to us. The page sends nothing but pings
+   * and a close, so a frame over MAX_CLIENT_FRAME, a buffer over MAX_CLIENT_BUFFER or an unmasked
+   * frame (RFC 6455 5.1) closes the connection rather than growing memory.
+   */
   read(d) {
+    if (this.buf.length + d.length > MAX_CLIENT_BUFFER)
+      return this.close();
     this.buf = Buffer.concat([this.buf, d]);
     while (this.buf.length >= 2) {
       const opcode = this.buf[0] & 15;
@@ -777,15 +919,15 @@ var Socket = class {
         len = Number(this.buf.readBigUInt64BE(2));
         off = 10;
       }
+      if (!masked || len > MAX_CLIENT_FRAME)
+        return this.close();
       const maskOff = off;
-      if (masked)
-        off += 4;
+      off += 4;
       if (this.buf.length < off + len)
         return;
       const payload = Buffer.from(this.buf.subarray(off, off + len));
-      if (masked)
-        for (let i = 0; i < payload.length; i++)
-          payload[i] ^= this.buf[maskOff + i % 4];
+      for (let i = 0; i < payload.length; i++)
+        payload[i] ^= this.buf[maskOff + i % 4];
       this.buf = this.buf.subarray(off + len);
       if (opcode === 8)
         return this.close();
@@ -842,11 +984,8 @@ var EventHub = class {
   }
 };
 var MAX_BODY = 4 * 1024 * 1024;
-function sameToken(a, b) {
-  const x = Buffer.from(a);
-  const y = Buffer.from(b);
-  return x.length === y.length && timingSafeEqual(x, y);
-}
+var sameToken = sameSecret;
+var STRONG = /^[A-Za-z0-9_-]{32,}$/;
 async function readBody(req, max = MAX_BODY) {
   const chunks = [];
   let size = 0;
@@ -888,9 +1027,11 @@ async function startServer(o) {
   const host = o.host ?? "127.0.0.1";
   if (host !== "127.0.0.1")
     throw new Error(`Atticus only listens on 127.0.0.1 (asked for ${host}).`);
-  const token = o.token && /^[A-Za-z0-9_-]{32,}$/.test(o.token) ? o.token : randomBytes(32).toString("base64url");
+  const token = o.token && STRONG.test(o.token) ? o.token : randomBytes2(32).toString("base64url");
+  const pageKey = o.pageKey && STRONG.test(o.pageKey) && o.pageKey !== token ? o.pageKey : randomBytes2(32).toString("base64url");
   const events = new EventHub();
   const jobs = new JobManager((e) => events.publish(e));
+  const confirmations = new Confirmations();
   const person = o.user ? { handle: o.user, source: "given" } : await gitUser(o.root);
   const ctx = {
     root: o.root,
@@ -899,9 +1040,17 @@ async function startServer(o) {
     version: o.version ?? "0.0.0",
     full: o.full === true,
     events,
-    jobs
+    jobs,
+    confirmations
   };
-  const router = apiRoutes(new Router(), ctx).add("GET", "/api/jobs/{jobId}", ({ params }) => {
+  const router = apiRoutes(new Router(), ctx).add("POST", "/api/confirmations", ({ body }) => {
+    const b = api_exports.ConfirmationRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest(`Say which write and what for: { write: ${api_exports.CONFIRMED_WRITES.join(" | ")}, target }.`);
+    if (!b.data.pageKey || !sameSecret(b.data.pageKey, pageKey))
+      throw new HttpError(403, "Only the Atticus app asks for a confirmation", "A write to a shared system is a person's: they click it in the Atticus app, or run its command with --approve in a terminal. The session token alone (atticus ui --show-token) can't confirm one (ADR 0186).");
+    return { status: 201, body: confirmations.issue(b.data.write, b.data.target) };
+  }).add("GET", "/api/jobs/{jobId}", ({ params }) => {
     const j = jobs.get(params.jobId);
     if (!j)
       throw notFound(`There is no job ${params.jobId}.`);
@@ -947,7 +1096,7 @@ async function startServer(o) {
           throw new HttpError(403, "Requests must be addressed to this server");
         if (!o.staticDir || req.method !== "GET" && req.method !== "HEAD")
           throw new HttpError(404, "Not found", `Nothing is served at ${url.pathname}.`);
-        const f = await staticFile(o.staticDir, url.pathname, token);
+        const f = await staticFile(o.staticDir, url.pathname, token, pageKey);
         const { "X-Frame-Options": deny, ...rest } = HARDENING;
         res.writeHead(f.status, {
           ...o.embed ? rest : { ...rest, "X-Frame-Options": deny },
@@ -976,14 +1125,18 @@ async function startServer(o) {
       send(res, out.status, out.body);
       done(out.status);
     } catch (e) {
-      const err = e instanceof HttpError ? e : new HttpError(500, "Something went wrong", e instanceof Error ? e.message : String(e));
+      const err = e instanceof HttpError ? e : e instanceof FileChangedError ? new HttpError(409, "The file changed meanwhile", e.message) : (
+        // The message stays in the log (onRequest gets the error): an fs error names the
+        // metarepo's absolute path, which the page has no use for.
+        new HttpError(500, "Something went wrong", "The app's log (.atticus/logs/atticus.log) has the details.")
+      );
       send(res, err.status, problem(err), "application/problem+json");
       done(err.status, err.status >= 500 && e instanceof Error ? e : void 0);
     }
   });
   server.on("upgrade", (req, sock) => {
-    const url = new URL(req.url ?? "/", "http://127.0.0.1");
     try {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
       if (url.pathname !== "/api/events")
         throw new HttpError(404, "Not found");
       guard(req, url, true);
@@ -999,9 +1152,9 @@ Connection: close\r
     if (s)
       events.add(s);
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     server.once("error", reject);
-    server.listen(o.port ?? DEFAULT_PORT, host, () => resolve());
+    server.listen(o.port ?? DEFAULT_PORT, host, () => resolve2());
   });
   port = server.address().port;
   const watcher = o.watch === false ? void 0 : watchMetarepo({ root: o.root, publish: (e) => events.publish(e) });
@@ -1009,219 +1162,29 @@ Connection: close\r
     url: `http://127.0.0.1:${port}`,
     port,
     token,
+    pageKey,
+    confirmations,
     events,
     jobs,
     person,
     get following() {
       return watcher?.following ?? [];
     },
-    close: () => new Promise((resolve) => {
+    close: () => new Promise((resolve2) => {
       watcher?.close();
       events.closeAll();
       server.closeAllConnections?.();
-      server.close(() => resolve());
+      server.close(() => resolve2());
     })
   };
 }
 
-// packages/cli/dist/ui-api-cites.js
-var import_yaml = __toESM(require_dist(), 1);
-async function fingerprint(dirs) {
-  let count = 0;
-  let newest = 0;
-  const walk = async (d) => {
-    const entries = await readdir(d, { withFileTypes: true }).catch(() => []);
-    for (const e of entries) {
-      const p = join4(d, e.name);
-      if (e.isDirectory())
-        await walk(p);
-      else {
-        count++;
-        const s = await stat3(p).catch(() => void 0);
-        if (s && s.mtimeMs > newest)
-          newest = s.mtimeMs;
-      }
-    }
-  };
-  for (const d of dirs)
-    await walk(d);
-  return `${count}:${newest}`;
-}
-async function build(root) {
-  const index = /* @__PURE__ */ new Map();
-  const lineOf = (repo, path, line) => {
-    const files = index.get(repo) ?? /* @__PURE__ */ new Map();
-    index.set(repo, files);
-    const lines = files.get(path) ?? /* @__PURE__ */ new Map();
-    files.set(path, lines);
-    const l = lines.get(line) ?? { line, flows: [], records: [] };
-    lines.set(line, l);
-    return l;
-  };
-  for (const specRepo of await specRepos(root))
-    for (const f of (await readRepoSpec(root, specRepo, { cacheRoot: root })).flows) {
-      const parts = [
-        { step: 0, kind: f.trigger.kind, evidence: f.trigger.evidence },
-        ...f.steps.map((s, i) => ({
-          step: i + 1,
-          kind: s.kind,
-          ...s.confirmedBy ? { confirmedBy: s.confirmedBy } : {},
-          evidence: s.evidence
-        }))
-      ];
-      for (const part of parts)
-        for (const e of part.evidence) {
-          if (!e.path || e.line === void 0)
-            continue;
-          const l = lineOf(e.repo ?? specRepo, e.path, e.line);
-          if (l.flows.some((x) => x.flow === f.id && x.step === part.step))
-            continue;
-          l.flows.push({
-            repo: specRepo,
-            flow: f.id,
-            name: f.name,
-            step: part.step,
-            kind: part.kind,
-            ...part.confirmedBy ? { confirmedBy: part.confirmedBy } : {}
-          });
-        }
-    }
-  for (const r of await catalogRecords(root)) {
-    const name = r.name;
-    for (const e of r.evidence) {
-      if (!e.repo || !e.path || e.line === void 0)
-        continue;
-      const l = lineOf(e.repo, e.path, e.line);
-      if (l.records.some((x) => x.kind === r.kind && x.id === r.id))
-        continue;
-      l.records.push({
-        kind: r.kind,
-        id: r.id,
-        ...typeof name === "string" && name !== r.id ? { name } : {},
-        source: e.source
-      });
-    }
-  }
-  return index;
-}
-var DONE = /* @__PURE__ */ new Set(["released", "archived", "post-release-review"]);
-async function inFlight(root) {
-  const out = /* @__PURE__ */ new Map();
-  const dir = changesDirOf(root);
-  for (const e of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
-    if (!e.isDirectory() || e.name === "archive")
-      continue;
-    const yaml = await readFile3(join4(dir, e.name, "change.yaml"), "utf8").catch(() => "");
-    const state = (() => {
-      try {
-        return (0, import_yaml.parse)(yaml)?.state;
-      } catch {
-        return void 0;
-      }
-    })();
-    if (!yaml || typeof state === "string" && DONE.has(state))
-      continue;
-    for (const f of await readdir(join4(dir, e.name, "target-flows")).catch(() => []))
-      if (f.endsWith(".yaml")) {
-        const flow = f.slice(0, -".yaml".length);
-        out.set(flow, [...out.get(flow) ?? [], e.name]);
-      }
-  }
-  return out;
-}
-async function citeList(root, index, repo, path) {
-  const lines = [...index.get(repo)?.get(path)?.values() ?? []].sort((a, b) => a.line - b.line);
-  const flying = await inFlight(root);
-  const shown = lines.map((l) => ({
-    ...l,
-    flows: [...l.flows].sort((a, b) => a.flow.localeCompare(b.flow) || a.step - b.step).map((f) => flying.get(f.flow)?.length ? { ...f, changes: flying.get(f.flow) } : f)
-  }));
-  return { repo, path, lines: shown };
-}
-function fileInRepo(root, file) {
-  const rel = relative2(root, file);
-  if (!rel || rel.startsWith("..") || isAbsolute(rel))
-    return void 0;
-  const parts = rel.split(sep3);
-  if (parts[0] !== "workspace")
-    return { path: parts.join("/") };
-  const at = parts[1] === ".worktrees" ? 3 : parts[1] === ".branches" ? 2 : 1;
-  const repo = parts[at];
-  const rest = parts.slice(parts[1] === ".branches" ? 4 : at + 1);
-  if (!repo || !rest.length || !RecordId.safeParse(repo).success)
-    return void 0;
-  return { repo, path: rest.join("/") };
-}
-async function citesCli(root, o, io) {
-  let repo = o.repo;
-  let path = o.path;
-  const index = await build(root);
-  if (o.file) {
-    const at = fileInRepo(root, o.file);
-    if (!at) {
-      io.err(`${o.file} isn't in this metarepo or a repo's checkout in its workspace.`);
-      return 1;
-    }
-    path = at.path;
-    repo = at.repo ?? [...index.keys()].find((r) => index.get(r).has(at.path)) ?? void 0;
-    if (!repo) {
-      if (o.json)
-        io.out(JSON.stringify({ repo: "", path, lines: [] }, null, 2));
-      else
-        io.out(`Nothing in the specs or the catalog cites ${path}.`);
-      return 0;
-    }
-  }
-  if (!repo || !path || !RecordId.safeParse(repo).success) {
-    io.err("Say which file: atticus cites --repo <repo> --path <its path in the repo>, or --file <path on disk>.");
-    return 2;
-  }
-  const v = await citeList(root, index, repo, path);
-  if (o.json) {
-    io.out(JSON.stringify(v, null, 2));
-    return 0;
-  }
-  if (!v.lines.length) {
-    io.out(`Nothing in the specs or the catalog cites ${repo}/${path}.`);
-    return 0;
-  }
-  for (const l of v.lines) {
-    const flows = l.flows.map((f) => `${f.name} (step ${f.step})${f.changes?.length ? `, changed by ${f.changes.join(", ")}` : ""}`);
-    const records = l.records.map((r) => `${r.kind} ${r.name ?? r.id}`);
-    io.out(`Line ${l.line}: ${[...flows, ...records].join("; ")}`);
-  }
-  return 0;
-}
-function uiCiteRoutes(r, ctx) {
-  const root = ctx.root;
-  let cached;
-  const indexNow = async () => {
-    const print = await fingerprint([specsDirOf(root), catalogDirOf(root)]);
-    if (cached?.print !== print)
-      cached = { print, index: build(root) };
-    return cached.index;
-  };
-  void indexNow().catch(() => void 0);
-  r.add("GET", "/api/cites", async ({ query }) => {
-    const repo = query.get("repo");
-    const path = query.get("path");
-    if (!repo || !RecordId.safeParse(repo).success)
-      throw badRequest("Say which repo: ?repo=<the repo's id>.");
-    if (!path)
-      throw badRequest("Say which file: ?path=<its path in the repo>.");
-    return { status: 200, body: await citeList(root, await indexNow(), repo, path) };
-  });
-  return r;
-}
-
 export {
   HttpError,
   badRequest,
   notFound,
   conflict,
   strParam,
-  startServer,
-  fileInRepo,
-  citesCli,
-  uiCiteRoutes
+  requireConfirmation,
+  startServer
 };