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

package/dist/{chunk-HK3VOHIE.js → chunk-HRS5O7VV.js}

@@ -3,6 +3,11 @@ 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 {
+  readRound,
+  reviewedGates,
+  roundsOf
+} from "./chunk-D6BVLTDV.js";
 import {
   QueryError,
   askLookup,
@@ -10,21 +15,16 @@ import {
   impact,
   openIndex,
   translate
-} from "./chunk-5WERBKLE.js";
-import {
-  readRound,
-  reviewedGates,
-  roundsOf
-} from "./chunk-K332XW7K.js";
+} from "./chunk-RCG5IAAT.js";
 import {
   changeFolder,
   changeStore
-} from "./chunk-HSZMPH5T.js";
+} from "./chunk-WZYM5M4U.js";
 import {
   baseClonePath,
   gitUser,
   loadRepos
-} from "./chunk-XOL3GFW2.js";
+} from "./chunk-3EWKO457.js";
 import {
   API_VERSION,
   DEFAULT_PORT,
@@ -32,7 +32,10 @@ import {
   RECORD_KINDS,
   RecordId,
   Severity,
+  api_exports,
+  asksOfFinding,
   catalogDirOf,
+  catalogMayHaveChangedAt,
   factsDirOf,
   fastPathOf,
   inputsDirOf,
@@ -44,14 +47,17 @@ import {
   proposalsDirOf,
   questionOfLens,
   questionsDirOf,
+  rolesOfPerson,
   runsDirOf,
   specsDirOf,
   withSignal
-} from "./chunk-PAINMSID.js";
+} from "./chunk-FPBUTZI5.js";
 import {
   FileChangedError,
-  SCHEMA_VERSION
-} from "./chunk-ODMBPDDV.js";
+  SCHEMA_VERSION,
+  printToCurrent,
+  withPrinter
+} from "./chunk-B4AEL3RF.js";
 
 // packages/server/dist/http.js
 var HttpError = class extends Error {
@@ -135,125 +141,73 @@ function intParam(q, name, min, max) {
 }
 var strParam = (q, name) => q.get(name) || void 0;
 
-// 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;
-  /** 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 { existsSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 var queues = /* @__PURE__ */ new Map();
-async function withIndex(root, f) {
+var checked = /* @__PURE__ */ new Map();
+var TRUST_MS = 3e4;
+var following = /* @__PURE__ */ new Set();
+var changes = /* @__PURE__ */ new Map();
+function trustIndexBetweenChanges(root, on) {
+  if (on)
+    following.add(root);
+  else {
+    following.delete(root);
+    checked.delete(root);
+  }
+}
+function indexFilesChanged(root) {
+  for (const r of root ? [root] : [...following, ...checked.keys()]) {
+    checked.delete(r);
+    changes.set(r, (changes.get(r) ?? 0) + 1);
+  }
+}
+var embedding = /* @__PURE__ */ new Map();
+var asked = /* @__PURE__ */ new Map();
+function embedSoon(root) {
+  if (embedding.has(root) || process.env.ATTICUS_EMBEDDINGS === "off")
+    return;
+  const step = () => {
+    if (Date.now() - (asked.get(root) ?? 0) < 1500) {
+      embedding.set(root, setTimeout(step, 1e3).unref());
+      return;
+    }
+    void withIndex(root, (ix) => ix.embed({ max: 8 }), { meaning: true }).then((n) => n > 0, () => false).then((more) => {
+      if (more && embedding.has(root))
+        embedding.set(root, setTimeout(step, 50).unref());
+      else
+        embedding.delete(root);
+    });
+  };
+  embedding.set(root, setTimeout(step, 2e3).unref());
+}
+function stopEmbedding(root) {
+  const t = embedding.get(root);
+  if (t)
+    clearTimeout(t);
+  embedding.delete(root);
+}
+async function withIndex(root, f, o = {}) {
+  if (!o.meaning)
+    asked.set(root, Date.now());
   const before = queues.get(root) ?? Promise.resolve();
   const mine = before.then(async () => {
-    const ix = await openIndex(root);
+    const trusted = following.has(root) && Date.now() - (checked.get(root) ?? -Infinity) < TRUST_MS;
+    const at = changes.get(root) ?? 0;
+    const ix = await openIndex(root, {
+      embedOnOpen: 0,
+      // Only search and ask compare by meaning; the counts, lists and graph never need the model.
+      ...o.meaning ? {} : { embeddings: "off" },
+      ...trusted ? { trusted: true } : {}
+    });
+    if (!trusted && following.has(root) && (changes.get(root) ?? 0) === at)
+      checked.set(root, Date.now());
+    if (!trusted && !o.meaning)
+      embedSoon(root);
     try {
-      return f(ix);
+      return await f(ix);
     } finally {
       ix.close();
     }
@@ -316,7 +270,9 @@ function apiRoutes(r, ctx) {
       root,
       openspec: layoutOf(root).openspec.replace(/\/+$/, ""),
       user: ctx.user,
-      full: ctx.full === true
+      full: ctx.full === true,
+      // ADR 0190: in a folder that isn't a metarepo yet, the app offers to create one.
+      metarepo: existsSync(join(root, "org-pack")) || existsSync(join(root, ".atticus", "org-pack"))
     }
   })).add("GET", "/api/catalog/kinds", async () => ({
     status: 200,
@@ -356,26 +312,25 @@ function apiRoutes(r, ctx) {
     const q = strParam(query, "q");
     if (!q)
       throw badRequest("Ask a question: ?q=<plain words>.");
-    return {
-      status: 200,
-      body: await withIndex(root, (ix) => {
-        const asked = translate(q, askLookup(ix));
-        if (asked.action === "impact")
-          return { question: q, ...asked, impact: impact(ix, asked.id, 4) };
-        if (asked.action === "owner") {
-          const r2 = ix.find(asked.id)[0];
-          const owner = r2?.owner ?? r2?.ownerComponent ?? (r2 ? ix.find(String(r2.system ?? ""))[0]?.owner : void 0);
-          return { question: q, ...asked, owner: owner ?? null };
-        }
-        try {
-          return { question: q, ...asked, result: ix.query(asked.query, { limit: 60 }) };
-        } catch (e) {
-          if (e instanceof QueryError)
-            return { question: q, ...asked, error: e.message };
-          throw e;
-        }
-      })
-    };
+    const knowledge = ctx.askKnowledge ? await ctx.askKnowledge(q).catch(() => void 0) : void 0;
+    const answer = await withIndex(root, (ix) => {
+      const asked2 = translate(q, askLookup(ix));
+      if (asked2.action === "impact")
+        return { question: q, ...asked2, impact: impact(ix, asked2.id, 4) };
+      if (asked2.action === "owner") {
+        const r2 = ix.find(asked2.id)[0];
+        const owner = r2?.owner ?? r2?.ownerComponent ?? (r2 ? ix.find(String(r2.system ?? ""))[0]?.owner : void 0);
+        return { question: q, ...asked2, owner: owner ?? null };
+      }
+      try {
+        return { question: q, ...asked2, result: ix.query(asked2.query, { limit: 60 }) };
+      } catch (e) {
+        if (e instanceof QueryError)
+          return { question: q, ...asked2, error: e.message };
+        throw e;
+      }
+    });
+    return { status: 200, body: knowledge ? { ...answer, knowledge } : answer };
   }).add("GET", "/api/graph", async ({ query }) => {
     const depth = intParam(query, "depth", 1, 6);
     const o = {
@@ -449,7 +404,7 @@ function apiRoutes(r, ctx) {
     if (!res)
       throw notFound(`There is no record ${params.id} in the catalog.`);
     const near = /* @__PURE__ */ new Set([...res.systems, params.id, ...res.reach.affected.map((a) => a.id)]);
-    const changes = (await changeStore(root).list()).filter((c) => c.systems.some((s) => near.has(s)) || [...c.touches.records, ...c.touches.tables, ...c.touches.dataStores].some((x) => near.has(x))).map((c) => ({
+    const changes2 = (await changeStore(root).list()).filter((c) => c.systems.some((s) => near.has(s)) || [...c.touches.records, ...c.touches.tables, ...c.touches.dataStores].some((x) => near.has(x))).map((c) => ({
       id: c.id,
       title: c.title,
       state: c.state,
@@ -466,7 +421,7 @@ function apiRoutes(r, ctx) {
         call: res.owners,
         ownerUnknown: res.unowned,
         watch: res.watch,
-        recentChanges: changes
+        recentChanges: changes2
       }
     };
   }).add("GET", "/api/repos", async () => {
@@ -479,13 +434,18 @@ function apiRoutes(r, ctx) {
     return { status: 200, body };
   }).add("GET", "/api/changes", async ({ query }) => {
     const state = strParam(query, "state");
-    const changes = (await changeStore(root).list()).filter((c) => !state || c.state === state);
+    const changes2 = (await changeStore(root).list()).filter((c) => !state || c.state === state);
     const body = [];
-    const types = await loadOrgPack(orgPackDirOf(root)).then((op) => op.changeTypes.types, () => []);
-    for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+    const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+    const types = op?.changeTypes.types ?? [];
+    const custom = op?.roles?.custom ?? [];
+    for (const c of changes2.sort((a, b) => a.id.localeCompare(b.id))) {
       const type = types.find((t) => t.id === c.type);
       const fast = !!type && (type.size === "small" || !!type.smallWhenBriefSays) && fastPathOf(type, await readFile(join(changeFolder(root, c.id), "brief.md"), "utf8").catch(() => "")).fast;
-      body.push(summary(c, await latestFindings(root, c.id), fast));
+      body.push({
+        ...summary(c, await latestFindings(root, c.id), fast),
+        yourRoles: rolesOfPerson(ctx.user, c.owners ?? {}, custom)
+      });
     }
     return { status: 200, body };
   }).add("GET", "/api/findings", async ({ query }) => {
@@ -496,13 +456,16 @@ function apiRoutes(r, ctx) {
     const state = strParam(query, "state");
     const lens = enumParam(query, "lens", Lens.options);
     const severity = enumParam(query, "severity", Severity.options);
+    const asks = enumParam(query, "asks", ["business", "design", "delivery"]);
     const ids = change ? [change] : (await changeStore(root).list()).map((c) => c.id).sort();
     const body = [];
     for (const id of ids)
-      for (const f of await latestFindings(root, id))
+      for (const f of await latestFindings(root, id)) {
+        const level = asksOfFinding(f);
         if ((!gate || f.gate === gate) && (!state || f.state === state) && // A lens filter asks its question: an old lens name finds what its question raised.
-        (!lens || questionOfLens(f.lens) === questionOfLens(lens)) && (!severity || f.severity === severity))
-          body.push(f);
+        (!lens || questionOfLens(f.lens) === questionOfLens(lens)) && (!severity || f.severity === severity) && (!asks || level === asks))
+          body.push({ ...f, asks: level });
+      }
     return { status: 200, body };
   }).add("GET", "/api/findings/{changeId}/{findingId}", async ({ params }) => {
     if (!RecordId.safeParse(params.changeId).success)
@@ -549,6 +512,224 @@ function apiRoutes(r, ctx) {
   });
 }
 
+// packages/server/dist/server.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { createServer } from "node:http";
+
+// packages/server/dist/jobs.js
+var JOB_LINES = 5e3;
+var JOBS_KEPT = 100;
+var jobLine = (line) => printToCurrent(line);
+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();
+  printed = /* @__PURE__ */ new Map();
+  metas = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  ends = /* @__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);
+  }
+  /** Every job kept, newest first (ADR 0187). */
+  list() {
+    return [...this.jobs.values()].reverse();
+  }
+  /** What a job belongs to, as it was started. */
+  metaOf(id) {
+    return this.metas.get(id);
+  }
+  /** A job's printed lines from a line on (or its last `max`), and how many it printed. */
+  linesOf(id, from, max = JOB_LINES) {
+    const p = this.printed.get(id);
+    if (!p)
+      return void 0;
+    const total = p.from + p.lines.length;
+    const start = from === void 0 ? Math.max(total - max, p.from) : Math.max(Math.min(from, total), p.from);
+    return { from: start, lines: p.lines.slice(start - p.from, start - p.from + max), total };
+  }
+  /** Hear each job's new lines and changes of state. */
+  subscribe(f) {
+    this.listeners.add(f);
+    return () => this.listeners.delete(f);
+  }
+  tell(c) {
+    for (const f of this.listeners) {
+      try {
+        f(c);
+      } catch {
+      }
+    }
+  }
+  print(job, text) {
+    const p = this.printed.get(job.id);
+    if (!p)
+      return;
+    const lines = String(text).split(/\r?\n/);
+    const at = p.from + p.lines.length;
+    p.lines.push(...lines);
+    if (p.lines.length > JOB_LINES) {
+      const drop = p.lines.length - JOB_LINES;
+      p.lines.splice(0, drop);
+      p.from += drop;
+    }
+    this.tell({ type: "lines", job, at, lines });
+  }
+  /** Finished jobs past JOBS_KEPT go, oldest first; running ones stay. */
+  forget() {
+    let over = this.jobs.size - JOBS_KEPT;
+    if (over <= 0)
+      return;
+    for (const [id, j] of this.jobs) {
+      if (over <= 0)
+        break;
+      if (j.state === "running" || j.state === "queued")
+        continue;
+      this.jobs.delete(id);
+      this.printed.delete(id);
+      this.metas.delete(id);
+      this.cancelledIds.delete(id);
+      over--;
+    }
+  }
+  start(kind, work, o = {}) {
+    const id = `job-${++this.seq}`;
+    const job = {
+      id,
+      kind,
+      state: "running",
+      progress: { done: 0, total: 0, message: "Starting" },
+      ...o.title ? { title: o.title } : {},
+      startedAt: this.now().toISOString(),
+      errors: []
+    };
+    this.jobs.set(id, job);
+    this.printed.set(id, { from: 0, lines: [] });
+    if (o.meta)
+      this.metas.set(id, { ...o.meta });
+    this.forget();
+    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 line = (text) => this.print(job, text);
+    const control = {
+      progress: (done, total, message) => {
+        job.progress = { done, total, message };
+        this.publish({ type: "job.progress", jobId: id, done, total, message });
+        this.tell({ type: "state", job });
+      },
+      line,
+      get cancelled() {
+        return cancelled.has(id);
+      }
+    };
+    this.tell({ type: "state", job });
+    void (async () => {
+      try {
+        const out = await withPrinter(line, () => 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);
+      const p = this.printed.get(id);
+      if (p && p.from + p.lines.length === 0) {
+        const said = job.result?.lines;
+        const end = [
+          ...Array.isArray(said) ? said.filter((l) => typeof l === "string") : [],
+          ...job.errors.filter((e) => !(Array.isArray(said) && said.includes(e)))
+        ];
+        if (end.length)
+          line(end.join("\n"));
+      }
+      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 });
+      this.tell({ type: "state", job });
+      this.ends.get(id)?.();
+      this.ends.delete(id);
+    })();
+    return job;
+  }
+  /**
+   * Run work the caller waits for as a job (ADR 0187): the route keeps its answer, and the
+   * Console shows what it printed. Resolves with the work's value, or throws its error.
+   */
+  track(kind, work, o = {}) {
+    return new Promise((resolve2, reject) => {
+      let value;
+      let failed;
+      const job = this.start(kind, async (c) => {
+        try {
+          value = await work(c);
+        } catch (e) {
+          failed = { e };
+          throw e;
+        }
+      }, o);
+      this.ends.set(job.id, () => failed ? reject(failed.e) : resolve2(value));
+    });
+  }
+  /** 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, resolve, sep } from "node:path";
@@ -580,7 +761,7 @@ function appCsp(port, embed) {
   ].join("; ");
 }
 var escapeAttr = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
-async function staticFile(givenDir, path, token) {
+async function staticFile(givenDir, path, token, pageKey) {
   const dir = resolve(givenDir);
   let rel;
   try {
@@ -600,7 +781,12 @@ async function staticFile(givenDir, 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 {
@@ -612,12 +798,121 @@ async function staticFile(givenDir, 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"
+  },
+  // Review round 50: committing them doesn't stand for the person's yes (the assistant can
+  // commit); the address the person last confirmed does (kept outside the metarepo).
+  "ai-test": {
+    what: "Testing the model settings sends the key to an address you haven't confirmed",
+    cli: "a step in model mode yourself"
+  },
+  // ADR 0191: the plan's work items written to a live tracker, and an owner question sent.
+  "work-items": {
+    what: "Putting the plan's stories and tasks in the work tracker writes work items",
+    cli: "atticus ado sync <change> --approve <you>"
+  },
+  "owner-ask": {
+    what: "Sending an owner question posts a message",
+    cli: "copy the question and ask the owner yourself"
+  }
+};
+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";
 var SKIP = /* @__PURE__ */ new Set([".git", "node_modules", ".index", "workspace", "logs", ".vitest-cache"]);
-var TEMP = /(~|\.swp|\.swx|\.tmp|\.crdownload|\.part)$/i;
+var TEMP = /(~|\.swp|\.swx|\.tmp|\.crdownload|\.part|(^|\/)\.doctor-\d+)$/i;
 var posix = (p) => p.split(sep2).join("/");
+function onlyRead(abs, seen, since) {
+  let s;
+  try {
+    s = statSync(abs);
+  } catch {
+    seen.delete(abs);
+    return false;
+  }
+  const now = `${s.size}:${s.mtimeMs}:${s.ctimeMs}`;
+  const was = seen.get(abs);
+  seen.set(abs, now);
+  return was !== void 0 ? was === now : Math.max(s.mtimeMs, s.ctimeMs) < since;
+}
 var isDir = (p) => {
   try {
     return statSync(p).isDirectory();
@@ -640,6 +935,8 @@ function watchMetarepo(o) {
   };
   const problems = [];
   const pending = /* @__PURE__ */ new Set();
+  const stamps = /* @__PURE__ */ new Map();
+  const since = Date.now();
   let timer;
   let first = 0;
   let closed = false;
@@ -685,17 +982,39 @@ function watchMetarepo(o) {
     const unique = [...new Set(all)].sort();
     return unique.filter((d) => !unique.some((p) => p !== d && d.startsWith(p + sep2)));
   };
+  const logsDir = join3(root, ".atticus", "logs");
+  const runLogDirs = [join3(logsDir, "running"), join3(logsDir, "runs")];
+  const runLogDelay = o.runLogDelayMs ?? 200;
+  let runLogTimer;
+  let runLogLast = 0;
+  const runLogChanged = () => {
+    if (runLogTimer || !o.onRunLog)
+      return;
+    runLogTimer = setTimeout(() => {
+      runLogTimer = void 0;
+      runLogLast = Date.now();
+      if (!closed)
+        o.onRunLog?.();
+    }, Math.max(runLogLast + runLogDelay - Date.now(), 0));
+  };
   const follow = (dir, recursive) => {
     if (closed || watchers.has(dir) || !isDir(dir))
       return;
     try {
-      const w = watch(dir, { recursive }, (_event, name) => {
+      const w = watch(dir, { recursive }, (event, name) => {
+        if (dir === logsDir)
+          return attach();
+        if (runLogDirs.includes(dir))
+          return runLogChanged();
         if (!recursive && name) {
           attach();
           if (watchers.has(join3(dir, String(name))))
             return;
         }
-        note(name ? join3(dir, String(name)) : dir);
+        const abs = name ? join3(dir, String(name)) : dir;
+        if (event === "change" && process.platform === "win32" && onlyRead(abs, stamps, since))
+          return;
+        note(abs);
       });
       w.on("error", (e) => {
         w.close();
@@ -730,16 +1049,22 @@ function watchMetarepo(o) {
     follow(join3(root, ".atticus"), false);
     for (const d of folders())
       follow(d, true);
+    if (o.onRunLog) {
+      follow(logsDir, false);
+      for (const d of runLogDirs)
+        follow(d, false);
+    }
   };
   attach();
   return {
     get following() {
-      return [...watchers.keys()].filter((d) => d !== root && d !== join3(root, ".atticus")).map((d) => posix(relative(root, d))).sort();
+      return [...watchers.keys()].filter((d) => d !== root && d !== join3(root, ".atticus") && d !== logsDir && !runLogDirs.includes(d)).map((d) => posix(relative(root, d))).sort();
     },
     problems,
     close() {
       closed = true;
       clearTimeout(timer);
+      clearTimeout(runLogTimer);
       for (const w of watchers.values())
         w.close();
       watchers.clear();
@@ -863,9 +1188,27 @@ function upgrade(req, sock, onClose) {
 }
 
 // packages/server/dist/server.js
+var JOB_KINDS = {
+  scan: true,
+  sync: true,
+  reconcile: true,
+  index: true,
+  intake: true,
+  step: true,
+  local: true,
+  work: true
+};
 var EventHub = class {
+  root;
   sockets = /* @__PURE__ */ new Set();
   listeners = /* @__PURE__ */ new Set();
+  /**
+   * `root`: each file.changed event is published saying whether it can change the catalog
+   * (`catalog`, beta.23 review), by the layout the org pack names, so a page needn't guess it.
+   */
+  constructor(root) {
+    this.root = root;
+  }
   /** Hear every event in this process too (ADR 0119: a reader that keeps files in memory). */
   listen(fn) {
     this.listeners.add(fn);
@@ -880,7 +1223,16 @@ var EventHub = class {
   get size() {
     return this.sockets.size;
   }
-  publish(e) {
+  publish(given) {
+    let e = given;
+    if (this.root !== void 0 && e.type === "file.changed" && typeof e.path === "string" && typeof e.catalog !== "boolean") {
+      let catalog = true;
+      try {
+        catalog = catalogMayHaveChangedAt(this.root, e.path);
+      } catch {
+      }
+      e = { ...e, catalog };
+    }
     for (const fn of this.listeners)
       fn(e);
     const text = JSON.stringify(e);
@@ -892,12 +1244,24 @@ var EventHub = class {
       s.close();
   }
 };
+var Signal = class {
+  fs = /* @__PURE__ */ new Set();
+  subscribe(f) {
+    this.fs.add(f);
+    return () => this.fs.delete(f);
+  }
+  emit() {
+    for (const f of this.fs) {
+      try {
+        f();
+      } catch {
+      }
+    }
+  }
+};
 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;
@@ -939,10 +1303,15 @@ 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 events = new EventHub();
+  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(o.root);
+  let writing = 0;
   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 runLogs = new Signal();
+  const onClose = /* @__PURE__ */ new Set();
   const ctx = {
     root: o.root,
     user: person.handle,
@@ -950,9 +1319,19 @@ async function startServer(o) {
     version: o.version ?? "0.0.0",
     full: o.full === true,
     events,
-    jobs
+    jobs,
+    confirmations,
+    runLogs,
+    onClose
   };
-  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}.`);
@@ -980,7 +1359,15 @@ async function startServer(o) {
   };
   const server = createServer(async (req, res) => {
     const t0 = Date.now();
+    let writes = req.method !== "GET" && req.method !== "HEAD";
+    if (writes)
+      writing++;
     const done = (status, error) => {
+      if (writes) {
+        writes = false;
+        writing--;
+        indexFilesChanged(o.root);
+      }
       const path = (req.url ?? "/").split("?")[0];
       if (path.startsWith("/api/"))
         o.onRequest?.({
@@ -998,7 +1385,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 },
@@ -1059,19 +1446,43 @@ Connection: close\r
     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) });
+  const watcher = o.watch === false ? void 0 : watchMetarepo({
+    root: o.root,
+    publish: (e) => events.publish(e),
+    onRunLog: () => runLogs.emit()
+  });
+  const stopHearing = events.listen((e) => {
+    if (e.type === "file.changed" || e.type === "index.rebuilt" || e.type === "job.done")
+      indexFilesChanged(o.root);
+  });
+  if (watcher)
+    trustIndexBetweenChanges(o.root, true);
   return {
     url: `http://127.0.0.1:${port}`,
     port,
     token,
+    pageKey,
+    confirmations,
     events,
     jobs,
     person,
     get following() {
       return watcher?.following ?? [];
     },
+    get quiet() {
+      return writing === 0 && !Object.keys(JOB_KINDS).some((k) => jobs.runningOf(k));
+    },
     close: () => new Promise((resolve2) => {
       watcher?.close();
+      for (const f of onClose) {
+        try {
+          f();
+        } catch {
+        }
+      }
+      stopHearing();
+      trustIndexBetweenChanges(o.root, false);
+      stopEmbedding(o.root);
       events.closeAll();
       server.closeAllConnections?.();
       server.close(() => resolve2());
@@ -1084,6 +1495,33 @@ export {
   badRequest,
   notFound,
   conflict,
+  Router,
+  problem,
+  intParam,
   strParam,
+  trustIndexBetweenChanges,
+  indexFilesChanged,
+  stopEmbedding,
+  apiRoutes,
+  JOB_LINES,
+  JOBS_KEPT,
+  jobLine,
+  JobManager,
+  appCsp,
+  staticFile,
+  CONFIRM_TTL_MS,
+  Confirmations,
+  sameSecret,
+  needsConfirmation,
+  requireConfirmation,
+  onlyRead,
+  watchMetarepo,
+  acceptKey,
+  frame,
+  Socket,
+  upgrade,
+  EventHub,
+  Signal,
+  HARDENING,
   startServer
 };