@maycombhq/atticus 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/chunk-SMFFUFMN.js

@@ -0,0 +1,1876 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  keptFilesMayHaveChanged
+} from "./chunk-NWMFVPEP.js";
+
+// packages/core/dist/cite.js
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var PARAM = /^(\{[^}]*\}|:[^/]+|<[^>]+>|\$\{[^}]*\})$/;
+var PARAM_RE = "(?:\\{[^}]*\\}|:[A-Za-z_]\\w*|<[^>]+>|\\$\\{[^}]*\\})";
+var fieldKey = (f) => f.split(".").pop().toLowerCase().replace(/[^a-z0-9]/g, "");
+function lineNamesRoute(line, path) {
+  const segs = path.split(/[?#]/, 1)[0].split("/").filter(Boolean);
+  if (!segs.some((s) => !PARAM.test(s))) {
+    const body = segs.map((s) => PARAM.test(s) ? PARAM_RE : escape(s)).join("/");
+    if (new RegExp(`["'\`]/${body}/?["'\`]`).test(line))
+      return true;
+    if (!segs.length && /\bpath:\s*(['"`])\1|\bindex:\s*true\b/.test(line))
+      return true;
+    const head = segs.slice(0, -1).map(() => PARAM_RE).join("/");
+    return segs.length > 0 && new RegExp(`["'\`]/${head ? `${head}/` : ""}["'\`]\\s*\\+`).test(line);
+  }
+  for (let k = 0; k < segs.length; k++) {
+    const tail = segs.slice(k);
+    if (!tail.some((s) => !PARAM.test(s)))
+      break;
+    const re = new RegExp(`(?:/|["'\`])${tail.map((s) => PARAM.test(s) ? PARAM_RE : escape(s)).join("/")}(?![A-Za-z0-9_-])`, "i");
+    if (re.test(line))
+      return true;
+    const last = tail[tail.length - 1];
+    if (PARAM.test(last) && tail.length > 1) {
+      const head = tail.slice(0, -1);
+      const re2 = new RegExp(`/${head.map((s) => PARAM.test(s) ? PARAM_RE : escape(s)).join("/")}/?["'\`]`, "i");
+      if (re2.test(line))
+        return true;
+    }
+  }
+  return false;
+}
+var lineNamesWord = (line, word) => {
+  const w = word.trim();
+  if (!w)
+    return false;
+  const before = /^[A-Za-z0-9_]/.test(w) ? "(^|[^A-Za-z0-9_])" : "";
+  const after = /[A-Za-z0-9_]$/.test(w) ? "($|[^A-Za-z0-9_])" : "";
+  return new RegExp(`${before}${escape(w)}${after}`, "i").test(line);
+};
+var lineNamesField = (line, field) => {
+  const k = fieldKey(field);
+  return k.length > 0 && line.toLowerCase().replace(/[^a-z0-9]/g, " ").replace(/ /g, "").includes(k);
+};
+var lineNamesClaim = (line, c) => c.kind === "route" ? lineNamesRoute(line, c.value) : c.kind === "word" ? lineNamesWord(line, c.value) : lineNamesField(line, c.value);
+function claimOnLines(lines, line, claim, window = 1) {
+  const from = Math.max(1, line - window);
+  const to = Math.min(lines.length, line + window);
+  for (let i = from; i <= to; i++)
+    if (lineNamesClaim(lines[i - 1] ?? "", claim))
+      return true;
+  return false;
+}
+function normalizeQuote(q) {
+  return q.replace(/\r\n?/g, "\n").replace(/[‘’‚]/g, "'").replace(/[“”„]/g, '"').replace(/\s+/g, " ").trim().replace(/[;,.]+$/, "").trim();
+}
+function quoteMatches(line, quote) {
+  if (!quote)
+    return true;
+  const q = normalizeQuote(quote).replace(/"/g, "'");
+  if (q === "")
+    return true;
+  const l = normalizeQuote(line).replace(/"/g, "'");
+  const at = q.indexOf("<redacted>");
+  if (at >= 0)
+    return at === 0 || l.includes(q.slice(0, at).trimEnd());
+  return l === q || l.startsWith(q) || l.includes(q);
+}
+var BINARY = /\.(png|jpe?g|gif|webp|ico|pdf|zip|jar|war|ear|gz|tgz|7z|exe|dll|so|dylib|class|wasm|woff2?|ttf|otf|mp[34]|mov|avi|bin|dat)$/i;
+var NOTEBOOK = /\.ipynb$/i;
+var MINIFIED = /(\.min\.(js|css)|[-.]bundle\.js|\.map)$/i;
+function isBinaryPath(path) {
+  return BINARY.test(path);
+}
+function quoteNotRequired(path, line) {
+  return BINARY.test(path) || NOTEBOOK.test(path) || MINIFIED.test(path) || line.length > 1e3;
+}
+var SECRET_PATH = [
+  /(^|\/)\.env(\.|$)/i,
+  /(^|\/)secrets?\//i,
+  /(^|\/)credentials?(\.|$)/i,
+  /\.(pem|key|p12|pfx|jks|keystore)$/i,
+  /(^|\/)id_(rsa|ed25519|ecdsa|dsa)(\.|$)/i
+];
+function isSecretPath(path) {
+  const p = path.replace(/\\/g, "/").split("/").map((x) => x.replace(/:.*$/, "").replace(/[. ]+$/, "")).join("/");
+  return SECRET_PATH.some((re) => re.test(p));
+}
+var SECRET_KEY = /(password|passwd|pwd|secret|token|api[-_]?key|access[-_]?key|private[-_]?key|client[-_]?secret|credential)/i;
+var PLACEHOLDER = /^(\$\{|\{\{|env:|vault:|secret:|ref:|<)/;
+var KEY_VALUE = /^(\s*[-"']?\s*)([A-Za-z0-9_.:-]*?(?:password|passwd|pwd|secret|token|api[-_]?key|access[-_]?key|private[-_]?key|credentials?))(["']?\s*[:=]\s*)(.+)$/i;
+var SECRET_WORDS = "(?:password|passwd|pwd|secret|token|api[-_]?key|access[-_]?key|private[-_]?key|credentials?)";
+var KEY_LITERAL = new RegExp(`((?:^|[^A-Za-z0-9_.$-])[A-Za-z0-9_.$-]*?${SECRET_WORDS}["'\`]?\\]?(?:\\s*:\\s*[A-Za-z_][\\w.<>?\\[\\]]*(?=\\s*=))?\\s*(?::=|=>|=(?!=)|:(?!:))\\s*)(["'\`])((?:(?!\\2)[^\\\\]|\\\\.)+)\\2`, "i");
+var SETTER_LITERAL = new RegExp(`(\\b(?:set|with)[A-Za-z0-9_]*?${SECRET_WORDS}\\s*\\(\\s*)(["'\`])((?:(?!\\2)[^\\\\]|\\\\.)+)\\2`, "i");
+var KEY_BARE = new RegExp(`((?:\\bexport\\s+|--|[?&;])[A-Za-z0-9_.-]*?${SECRET_WORDS}\\s*=\\s*)([^\\s&;"'\`]+)`, "gi");
+var URL_CREDENTIALS = /\b([a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:)([^\s@/]+)(?=@)/gi;
+var BEARER = /\b(Bearer\s+)([A-Za-z0-9._~+/-]{16,}=*)/g;
+var BASIC = /\b(Basic\s+)((?=[A-Za-z0-9+/]*[0-9+/=])[A-Za-z0-9+/]{12,}={0,2})/g;
+var TOKEN_SHAPES = [
+  /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+  /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{8,}/g,
+  /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+  /\bxox[abprs]-[A-Za-z0-9-]{10,}/g,
+  /\bAIza[0-9A-Za-z_-]{35}/g,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g
+];
+var TOKEN_PREFIXES = [
+  /\bgh[pousr]_/,
+  /\bgithub_pat_/,
+  /\bgl(?:pat|ptt|dt|rt|cbt|imt|soat|ffct|agent)-/,
+  /\bnpm_/,
+  /\bpypi-/,
+  /\bhf_/,
+  /\b(?:sk|rk|pk)[-_]/,
+  /\bwhsec_/,
+  /\bxox[abeprs]-/,
+  /\bxapp-/,
+  /\b(?:AKIA|ASIA|AGPA|AIDA|AROA|ANPA)[0-9A-Z]{4}/,
+  /\bAIza/,
+  /\beyJ/,
+  /\bya29\./,
+  /\bshp(?:at|ss|ca|pa)_/,
+  /\bdop_v1_/,
+  /\bSG\./,
+  /\bsq0(?:atp|csp|idp)-/,
+  /\bEAAA[A-Za-z0-9]/,
+  /\bSK[0-9a-fA-F]{8}/,
+  /\bAC[0-9a-f]{8}/,
+  /\bdapi[0-9a-f]{8}/,
+  /AccountKey=/i,
+  /SharedAccessSignature|[?&]sig=/i,
+  /\bBearer\s/i,
+  /\bBasic\s/i
+];
+var hasTokenPrefix = (text) => TOKEN_PREFIXES.some((re) => re.test(text));
+function hasSecretShape(text, o = {}) {
+  for (const m of text.matchAll(URL_CREDENTIALS))
+    if (!refersOnly(m[2]))
+      return true;
+  if (new RegExp(BEARER.source).test(text))
+    return true;
+  if (o.basic !== false && new RegExp(BASIC.source).test(text))
+    return true;
+  return TOKEN_SHAPES.some((re) => new RegExp(re.source).test(text));
+}
+function maskSecretShapes(text, mask = "***") {
+  let out = text.replace(URL_CREDENTIALS, (all2, head, pass) => refersOnly(pass) ? all2 : `${head}${mask}`);
+  out = out.replace(BEARER, `$1${mask}`).replace(BASIC, `$1${mask}`);
+  for (const re of TOKEN_SHAPES)
+    out = out.replace(re, mask);
+  return out;
+}
+function keyIsSecret(key) {
+  if (hasSecretShape(key))
+    return true;
+  for (const run of key.match(/[0-9a-f]{24,}|[0-9A-F]{24,}/g) ?? [])
+    if (/\d/.test(run) && /[a-f]/i.test(run))
+      return true;
+  const digitsAndLetters = /\d/.test(key) && /[A-Za-z]/.test(key);
+  if (key.length >= 32 && /^[A-Za-z0-9+/=]+$/.test(key) && digitsAndLetters)
+    return true;
+  if (key.length >= 32 && /^[A-Za-z0-9_-]+$/.test(key) && /\d/.test(key) && /[a-z]/.test(key) && /[A-Z]/.test(key))
+    return true;
+  if (key.length < 16 || !/^[A-Za-z0-9+/=]+$/.test(key) || !/\d/.test(key))
+    return false;
+  const kind = (c) => /\d/.test(c) ? 0 : /[a-z]/.test(c) ? 1 : 2;
+  let switches = 0;
+  for (let i = 1; i < key.length; i++)
+    if (kind(key[i]) !== kind(key[i - 1]))
+      switches++;
+  return switches >= key.length / 2;
+}
+var placeholder = (v) => PLACEHOLDER.test(v.trim().replace(/^["'`]/, ""));
+var refersOnly = (v) => placeholder(v) || /^[$%{]/.test(v);
+function redactSecrets(line) {
+  if (/-----BEGIN [A-Z ]*PRIVATE KEY-----/.test(line))
+    return "<redacted>";
+  let out = line;
+  if (SECRET_KEY.test(out)) {
+    const m = KEY_VALUE.exec(out);
+    if (m && !placeholder(m[4]))
+      out = `${m[1]}${m[2]}${m[3]}<redacted>`;
+    for (const re of [KEY_LITERAL, SETTER_LITERAL]) {
+      const k = re.exec(out);
+      if (k && !placeholder(k[3]))
+        out = `${out.slice(0, k.index)}${k[1]}<redacted>`;
+    }
+    out = out.replace(KEY_BARE, (all2, key, v) => refersOnly(v) || v === "<redacted>" ? all2 : `${key}<redacted>`);
+  }
+  out = out.replace(URL_CREDENTIALS, (all2, head, pass) => refersOnly(pass) ? all2 : `${head}<redacted>`);
+  out = out.replace(BEARER, "$1<redacted>").replace(BASIC, "$1<redacted>");
+  for (const re of TOKEN_SHAPES)
+    out = out.replace(re, "<redacted>");
+  return out;
+}
+var SECRET_IDENT = new RegExp(`[A-Za-z0-9_]*${SECRET_WORDS}[A-Za-z0-9_]*`, "i");
+var OPAQUE_LITERAL = /(["'`])([^\s"'`]{8,})\1/g;
+function quoteHoldsSecret(quote) {
+  if (!SECRET_IDENT.test(quote))
+    return false;
+  for (const m of quote.matchAll(OPAQUE_LITERAL)) {
+    const v = m[2];
+    if (/^[/.#$%{<]/.test(v) || v.includes("://") || placeholder(v))
+      continue;
+    if (/[A-Za-z]/.test(v) && /[0-9]/.test(v))
+      return true;
+  }
+  return false;
+}
+function defaultActionAt(lines, path) {
+  if (path.split(/[?#]/, 1)[0].replace(/\/+/g, "") !== "")
+    return false;
+  const text = lines.join("\n");
+  const mvc5 = /defaults:\s*new\s*\{[^}]*\}/.exec(text)?.[0];
+  if (!/MapDefaultControllerRoute|\{controller=\w+\}/.test(text) && !mvc5)
+    return false;
+  const controller = /\{controller=(\w+)\}/.exec(text)?.[1] ?? (mvc5 ? /controller\s*=\s*"(\w+)"/.exec(mvc5)?.[1] : void 0) ?? "Home";
+  const action = /\{action=(\w+)\}/.exec(text)?.[1] ?? (mvc5 ? /action\s*=\s*"(\w+)"/.exec(mvc5)?.[1] : void 0) ?? "Index";
+  return new RegExp(`\\b${controller}Controller\\b`).test(text) && new RegExp(`\\b${action}\\s*\\(`).test(text);
+}
+var WORD_SEP = "[:._/#\\s]";
+function partsBuildWord(claim, parts, lines) {
+  if (!parts.length)
+    return false;
+  let s = claim.trim();
+  for (const raw of parts) {
+    const v = raw.trim();
+    if (!v)
+      return false;
+    const before = new RegExp(`^${WORD_SEP}`).test(v) ? "" : `(?<=^|${WORD_SEP}|\\u0000)`;
+    const after = new RegExp(`${WORD_SEP}$`).test(v) ? "" : `(?=$|${WORD_SEP}|\\u0000)`;
+    const re = new RegExp(`${before}${escape(v)}${after}`, "i");
+    if (!re.test(s))
+      return false;
+    s = s.replace(re, "\0");
+  }
+  const edge = new RegExp(`^${WORD_SEP}+|${WORD_SEP}+$`, "g");
+  const rest = s.split("\0").map((p) => p.replace(edge, "")).filter(Boolean);
+  return rest.length > 0 && rest.every((p) => lines.some((l) => lineNamesWord(l, p)));
+}
+var pathPieces = (path) => path.split(/[?#]/, 1)[0].split("/").filter((s) => s && !PARAM.test(s)).flatMap((s) => s.split(".")).filter(Boolean);
+var linesNamePiece = (lines, p) => [p, p.replace(/-/g, "")].some((q) => lines.some((l) => new RegExp(`(^|[^A-Za-z0-9]|(?<=[a-z0-9])(?=[A-Z]))${escape(q)}`, "i").test(l)));
+function partsNamePath(lines, path) {
+  const parts = pathPieces(path);
+  if (!parts.length)
+    return lines.some((l) => lineNamesRoute(l, path)) || defaultActionAt(lines, path);
+  return parts.every((p) => linesNamePiece(lines, p));
+}
+function declaresConventionalRoute(texts) {
+  return texts.some((t) => /[{[]action(=\w*)?\??[}\]]|\bMapDefaultControllerRoute\b/i.test(t) || drfActionNamed(t));
+}
+function drfActionNamed(t) {
+  for (const m of t.matchAll(/@action\s*\(/g)) {
+    let depth = 1;
+    let i = m.index + m[0].length;
+    for (; i < t.length && depth > 0; i++)
+      if (t[i] === "(")
+        depth++;
+      else if (t[i] === ")")
+        depth--;
+    if (!/\burl_path\s*=/.test(t.slice(m.index, i)))
+      return true;
+  }
+  return false;
+}
+var commentText = (l) => l.replace(/^\s*(\/\/+|\/\*+|\*+|#+|<!--|--)/, "");
+var writesPieceAsPath = (l, p) => (
+  // after a quote, a `/`, a `:`, a tag's `>` or an interpolation's `}` (`"/balances"`, `'users'`,
+  // `:users`, `<Path>v1</Path>`, `$"{base}users"`, `${base}users`), and ending there
+  new RegExp(`["'\`/:>}]${escape(p)}(?![A-Za-z0-9_-])`, "i").test(l)
+);
+function pathPieceOnlyInComment(rawNear, isComment, partLines, path) {
+  const comments = rawNear.filter((l, i) => isComment(l, i)).map(commentText);
+  if (!comments.length)
+    return void 0;
+  const code = rawNear.filter((l, i) => !isComment(l, i));
+  return pathPieces(path).find((p) => !linesNamePiece(partLines, p) && comments.some((l) => writesPieceAsPath(l, p)) && !code.some((l) => writesPieceAsPath(l, p)));
+}
+
+// packages/core/dist/fs.js
+import { randomBytes } from "node:crypto";
+import { link, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+async function writeFileAtomic(path, data) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmp, data, typeof data === "string" ? "utf8" : void 0);
+    await renameRetrying(tmp, path);
+  } catch (e) {
+    await rm(tmp, { force: true });
+    throw e;
+  } finally {
+    keptFilesMayHaveChanged(path);
+  }
+}
+var FileChangedError = class extends Error {
+  path;
+  constructor(path) {
+    super(`${path} changed since it was read (another edit, or a person's): nothing was written. Read it again and redo the change.`);
+    this.path = path;
+  }
+};
+var writing = /* @__PURE__ */ new Map();
+function writeFileIfUnchanged(path, before, data) {
+  const key = resolve(path);
+  const prev = writing.get(key) ?? Promise.resolve();
+  const work = async () => {
+    const now = await readFile(path, "utf8").catch(() => void 0);
+    if (now !== before)
+      throw new FileChangedError(path);
+    await writeFileAtomic(path, data);
+  };
+  const next = prev.then(work, work);
+  const tail = next.catch(() => void 0);
+  writing.set(key, tail);
+  void tail.then(() => {
+    if (writing.get(key) === tail)
+      writing.delete(key);
+  });
+  return next;
+}
+var BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+async function renameRetrying(from, to, tries = 9) {
+  for (let i = 0; ; i++) {
+    try {
+      await rename(from, to);
+      return;
+    } catch (e) {
+      const code = e.code ?? "";
+      if (!BUSY.has(code) || i >= tries - 1)
+        throw e;
+      await new Promise((r) => setTimeout(r, 20 * 2 ** i));
+    }
+  }
+}
+var LockHeldError = class extends Error {
+  held;
+  file;
+  constructor(held, file) {
+    super(`Another ${held.what} is running (process ${held.pid} on ${held.host}, since ${held.startedAt}). Wait for it to finish${file ? `; if nothing is running, delete ${file}` : ""}.`);
+    this.held = held;
+    this.file = file;
+    this.name = "LockHeldError";
+  }
+};
+var heldHere = /* @__PURE__ */ new Set();
+var lockFileOf = (root, name) => join(root, ".atticus", "locks", `${name}.json`);
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+async function readLock(root, name, o = {}) {
+  try {
+    const file = lockFileOf(root, name);
+    const info = JSON.parse(await readFile(file, "utf8"));
+    const here = info.host === hostname();
+    const age = (o.now ?? (() => /* @__PURE__ */ new Date()))().getTime() - Date.parse(info.startedAt);
+    const stale = here && (!alive(info.pid) || info.pid === process.pid && !heldHere.has(file)) || o.maxAgeMs !== void 0 && Number.isFinite(age) && age > o.maxAgeMs;
+    return { ...info, stale };
+  } catch {
+    return void 0;
+  }
+}
+async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Date(), o = {}) {
+  const file = lockFileOf(root, name);
+  await ensureLocalIgnore(root);
+  await mkdir(dirname(file), { recursive: true });
+  const info = {
+    pid: process.pid,
+    host: hostname(),
+    startedAt: now().toISOString(),
+    what
+  };
+  let interrupted;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      await writeFile(file, JSON.stringify(info), { encoding: "utf8", flag: "wx" });
+      heldHere.add(file);
+      const release = async () => {
+        const cur = await readLock(root, name);
+        if (cur && cur.pid === info.pid && cur.startedAt === info.startedAt)
+          await rm(file, { force: true });
+        heldHere.delete(file);
+      };
+      return interrupted ? { release, interrupted } : { release };
+    } catch (e) {
+      if (e.code !== "EEXIST")
+        throw e;
+      const held = await readLock(root, name, { ...o, now });
+      if (held && !held.stale)
+        throw new LockHeldError(held, file);
+      if (held) {
+        const { stale: _s, ...rest } = held;
+        interrupted = rest;
+      }
+      await rm(file, { force: true });
+    }
+  }
+  throw new Error(`Couldn't take the ${name} lock at ${file}.`);
+}
+var sharedLockFileOf = (path) => `${path}.lock`;
+var sharing = /* @__PURE__ */ new Map();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var QUICK_WRITE_LOCK = { maxAgeMs: 12e4 };
+function withSharedFileLock(path, work, o = {}) {
+  const key = resolve(path);
+  const prev = sharing.get(key) ?? Promise.resolve();
+  const run = async () => {
+    const release = await takeSharedLock(key, o);
+    try {
+      return await work();
+    } finally {
+      await release();
+    }
+  };
+  const next = prev.then(run, run);
+  const tail = next.catch(() => void 0);
+  sharing.set(key, tail);
+  void tail.then(() => {
+    if (sharing.get(key) === tail)
+      sharing.delete(key);
+  });
+  return next;
+}
+async function takeSharedLock(path, o) {
+  const file = sharedLockFileOf(path);
+  const staleMs = o.staleMs ?? 1e4;
+  const waitMs = o.waitMs ?? 15e3;
+  const info = {
+    pid: process.pid,
+    host: hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    what: o.what ?? `write of ${basename(path)}`,
+    token: randomBytes(8).toString("hex")
+  };
+  await mkdir(dirname(file), { recursive: true });
+  const start = Date.now();
+  let delay = 5;
+  for (; ; ) {
+    let code;
+    try {
+      await writeFile(file, JSON.stringify(info), { encoding: "utf8", flag: "wx" });
+      return () => releaseShared(file, info.token);
+    } catch (e) {
+      code = e.code ?? "";
+      if (code !== "EEXIST" && !BUSY.has(code))
+        throw e;
+    }
+    let held;
+    if (code === "EEXIST") {
+      const seen = await readFile(file, "utf8").catch(() => void 0);
+      if (seen === void 0)
+        continue;
+      held = parseLockInfo(seen);
+      if (await isStaleShared(file, held, staleMs, o.maxAgeMs)) {
+        await takeOver(file, seen, info.token);
+        continue;
+      }
+    }
+    if (Date.now() - start > waitMs)
+      throw new LockHeldError(held ?? { pid: 0, host: "?", startedAt: "?", what: `write of ${basename(path)}` }, file);
+    await sleep(delay + Math.floor(Math.random() * delay));
+    delay = Math.min(delay * 2, 100);
+  }
+}
+function parseLockInfo(text) {
+  try {
+    const j = JSON.parse(text);
+    return typeof j.pid === "number" && typeof j.startedAt === "string" ? {
+      pid: j.pid,
+      host: String(j.host ?? ""),
+      startedAt: j.startedAt,
+      what: String(j.what ?? "")
+    } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function isStaleShared(file, held, staleMs, maxAgeMs) {
+  if (held && maxAgeMs !== void 0) {
+    const since2 = Date.parse(held.startedAt);
+    if (Number.isFinite(since2) && Date.now() - since2 > maxAgeMs)
+      return true;
+  }
+  if (held && held.host === hostname() && held.pid !== process.pid)
+    return !alive(held.pid);
+  const since = held ? Date.parse(held.startedAt) : await stat(file).then((s) => s.mtimeMs, () => NaN);
+  return Number.isFinite(since) && Date.now() - since > staleMs;
+}
+async function takeOver(file, seen, token) {
+  const aside = `${file}.${token}.stale`;
+  try {
+    await rename(file, aside);
+  } catch {
+    return;
+  }
+  const moved = await readFile(aside, "utf8").catch(() => void 0);
+  if (moved !== void 0 && moved !== seen)
+    await link(aside, file).catch(() => void 0);
+  await rmRetrying(aside);
+}
+async function releaseShared(file, token) {
+  const now = await readFile(file, "utf8").catch(() => void 0);
+  if (now === void 0)
+    return;
+  try {
+    if (JSON.parse(now).token !== token)
+      return;
+  } catch {
+    return;
+  }
+  await rmRetrying(file);
+}
+async function rmRetrying(file, tries = 9) {
+  for (let i = 0; ; i++) {
+    try {
+      await rm(file, { force: true });
+      return;
+    } catch (e) {
+      const code = e.code ?? "";
+      if (!BUSY.has(code) || i >= tries - 1)
+        throw e;
+      await sleep(20 * 2 ** i);
+    }
+  }
+}
+var LOCAL_ONLY = [
+  "me.yaml",
+  "logs/",
+  "locks/",
+  "backups/",
+  "history/",
+  "probe/",
+  "cache/",
+  // ADR 0161: where `atticus map --all` is in the estate, so running it again resumes.
+  "map-all/"
+];
+async function ensureLocalIgnore(root) {
+  const file = join(root, ".atticus", ".gitignore");
+  const text = await readFile(file, "utf8").catch(() => "");
+  const have = new Set(text.split(/\r?\n/).map((l) => l.trim()));
+  const missing = LOCAL_ONLY.filter((l) => !have.has(l));
+  if (!missing.length)
+    return;
+  const prefix = text && !text.endsWith("\n") ? `${text}
+` : text;
+  await writeFileAtomic(file, `${prefix}${prefix ? "" : "# This machine's own files: never committed.\n"}${missing.join("\n")}
+`);
+}
+
+// packages/core/dist/log.js
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import { join as join2 } from "node:path";
+var ORDER = { debug: 10, info: 20, warn: 30, error: 40, off: 100 };
+var LOG_MAX_BYTES = 5 * 1024 * 1024;
+var LOG_KEEP = 3;
+var logFileOf = (root) => join2(root, ".atticus", "logs", "atticus.log");
+var SECRET_KEY2 = /(token|password|passwd|pwd|secret|api[-_]?key|private[-_]?key|credential|authorization|cookie|session)/i;
+function redactText(s, o = {}) {
+  let out = s.replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s:]+:[^/@\s]+@/gi, "$1***@").replace(/\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, "$1 ***").replace(new RegExp(`(${SECRET_KEY2.source})(["']?\\s*[:=]\\s*["']?)([^\\s"',;&]+)`, "gi"), "$1$3***").replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}/g, "***").replace(/\b(?=[A-Za-z0-9+_-]*\d)(?=[A-Za-z0-9+_-]*[A-Z])(?=[A-Za-z0-9+_-]*[a-z])[A-Za-z0-9+_-]{32,}={0,2}/g, "***");
+  const home = o.home ?? safeHome();
+  if (home && home.length > 3)
+    out = out.split(home).join("~");
+  const user = o.user ?? safeUser();
+  if (user && user.length > 2)
+    out = out.replace(new RegExp(`([\\\\/])${escapeRe(user)}(?=[\\\\/])`, "g"), "$1<user>");
+  return out;
+}
+function redact(v, o = {}) {
+  if (typeof v === "string")
+    return redactText(v, o);
+  if (Array.isArray(v))
+    return v.map((x) => redact(x, o));
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const [k, x] of Object.entries(v))
+      out[k] = SECRET_KEY2.test(k) ? "***" : redact(x, o);
+    return out;
+  }
+  return v;
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function safeHome() {
+  try {
+    return homedir();
+  } catch {
+    return void 0;
+  }
+}
+function safeUser() {
+  try {
+    return userInfo().username;
+  } catch {
+    return void 0;
+  }
+}
+function rotate(file, max, keep) {
+  try {
+    if (statSync(file).size < max)
+      return;
+  } catch {
+    return;
+  }
+  rmSync(`${file}.${keep}`, { force: true });
+  for (let i = keep - 1; i >= 1; i--) {
+    try {
+      renameSync(`${file}.${i}`, `${file}.${i + 1}`);
+    } catch {
+    }
+  }
+  try {
+    renameSync(file, `${file}.1`);
+  } catch {
+  }
+}
+function logLevelFrom(env = process.env) {
+  const v = (env.ATTICUS_LOG ?? "").toLowerCase();
+  return v in ORDER ? v : "info";
+}
+function createLog(root, o = {}) {
+  const file = logFileOf(root);
+  const level = o.level ?? logLevelFrom();
+  const now = o.now ?? (() => /* @__PURE__ */ new Date());
+  const write = (lvl, event, fields) => {
+    if (ORDER[lvl] < ORDER[level])
+      return;
+    try {
+      mkdirSync(join2(file, ".."), { recursive: true });
+      ignoreLocalSync(root);
+      rotate(file, o.maxBytes ?? LOG_MAX_BYTES, o.keep ?? LOG_KEEP);
+      const entry = redact({ at: now().toISOString(), level: lvl, event, ...fields });
+      appendFileSync(file, `${JSON.stringify(entry)}
+`, "utf8");
+    } catch {
+    }
+  };
+  return {
+    file,
+    debug: (e, f = {}) => write("debug", e, f),
+    info: (e, f = {}) => write("info", e, f),
+    warn: (e, f = {}) => write("warn", e, f),
+    error: (e, err, f = {}) => write("error", e, {
+      ...f,
+      error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack?.split("\n").slice(0, 25) } : { message: String(err) }
+    })
+  };
+}
+function ignoreLocalSync(root) {
+  const f = join2(root, ".atticus", ".gitignore");
+  const text = existsSync(f) ? readFileSync(f, "utf8") : "";
+  const have = new Set(text.split(/\r?\n/).map((l) => l.trim()));
+  const missing = LOCAL_ONLY.filter((l) => !have.has(l));
+  if (!missing.length)
+    return;
+  const prefix = text && !text.endsWith("\n") ? `${text}
+` : text;
+  const head = prefix ? "" : "# This machine's own files: never committed.\n";
+  writeFileSync(f, `${prefix}${head}${missing.join("\n")}
+`, "utf8");
+}
+var NO_LOG = {
+  file: "",
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+
+// packages/core/dist/process-trees.js
+import { execFile, spawn } from "node:child_process";
+import { constants as osConstants } from "node:os";
+var live = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var TREE_SIGNAL_GRACE_MS = 1e4;
+var holds = 0;
+var pending;
+function stopTrackedTrees() {
+  for (const fn of listeners) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  for (const [, stop] of live) {
+    try {
+      stop("SIGTERM");
+    } catch {
+    }
+  }
+}
+function onStopping(fn) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+var own = /* @__PURE__ */ new Map();
+function onAtticusSignal(sig, fn, o = {}) {
+  const set = own.get(sig) ?? /* @__PURE__ */ new Map();
+  own.set(sig, set);
+  let gone = false;
+  const off = (later = false) => {
+    if (gone)
+      return;
+    gone = true;
+    process.off(sig, h);
+    if (later)
+      setImmediate(() => set.delete(fn));
+    else
+      set.delete(fn);
+  };
+  const h = () => {
+    if (o.once)
+      off(true);
+    fn(sig);
+  };
+  set.set(fn, { fallback: o.fallback === true });
+  process.on(sig, h);
+  return () => off();
+}
+function atticusHandles(sig, except) {
+  for (const [fn, h] of own.get(sig) ?? [])
+    if (fn !== except && !h.fallback)
+      return true;
+  return false;
+}
+var stopPending = () => pending !== void 0;
+var onSignal = (sig) => {
+  stopTrackedTrees();
+  if (atticusHandles(sig))
+    return;
+  if (!pending) {
+    pending = sig;
+    setTimeout(raise, TREE_SIGNAL_GRACE_MS).unref?.();
+  }
+  settle();
+};
+function raise() {
+  const sig = pending;
+  if (!sig)
+    return;
+  pending = void 0;
+  unhook();
+  try {
+    process.kill(process.pid, sig);
+  } catch {
+    process.exit(128 + (osConstants.signals[sig] ?? 1));
+  }
+}
+function settle() {
+  if (holds > 0 || live.size > 0)
+    return;
+  if (pending)
+    raise();
+  else
+    unhook();
+}
+var onExit = () => {
+  for (const [child, stop] of live) {
+    if (child.exitCode !== null || child.signalCode !== null)
+      continue;
+    try {
+      stop("SIGKILL");
+    } catch {
+    }
+  }
+};
+var hooked = false;
+function hook() {
+  if (hooked)
+    return;
+  hooked = true;
+  for (const s of SIGNALS)
+    process.prependListener(s, onSignal);
+  process.on("exit", onExit);
+}
+function unhook() {
+  if (!hooked)
+    return;
+  hooked = false;
+  for (const s of SIGNALS)
+    process.off(s, onSignal);
+  process.off("exit", onExit);
+}
+function trackTree(child, stop = (s) => stopProcessGroup(child, s)) {
+  live.set(child, stop);
+  hook();
+  let done = false;
+  return () => {
+    if (done)
+      return;
+    done = true;
+    live.delete(child);
+    settle();
+  };
+}
+function holdStop() {
+  holds++;
+  hook();
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    holds--;
+    settle();
+  };
+}
+var trackedTrees = () => live.size;
+function stopProcessGroup(child, signal = "SIGTERM") {
+  if (child.pid === void 0)
+    return;
+  if (process.platform === "win32") {
+    try {
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        windowsHide: true,
+        stdio: "ignore"
+      }).on("error", () => child.kill());
+    } catch {
+      child.kill();
+    }
+    return;
+  }
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    child.kill(signal);
+  }
+}
+function processDescendants(pid) {
+  return new Promise((resolve2) => {
+    execFile("ps", ["-A", "-o", "pid=,ppid=,lstart="], { encoding: "utf8", timeout: 2e3, windowsHide: true }, (err, text) => {
+      if (err) {
+        resolve2(/* @__PURE__ */ new Map());
+        return;
+      }
+      const kids = /* @__PURE__ */ new Map();
+      for (const line of text.split("\n")) {
+        const m = /^\s*(\d+)\s+(\d+)\s*(.*)$/.exec(line);
+        if (!m)
+          continue;
+        const p = Number(m[1]);
+        const pp = Number(m[2]);
+        kids.set(pp, [...kids.get(pp) ?? [], { pid: p, start: m[3].trim() }]);
+      }
+      const out = /* @__PURE__ */ new Map();
+      const walk = (p) => {
+        for (const k of kids.get(p) ?? []) {
+          if (out.has(k.pid))
+            continue;
+          out.set(k.pid, k.start);
+          walk(k.pid);
+        }
+      };
+      walk(pid);
+      resolve2(out);
+    });
+  });
+}
+function processesNow() {
+  return new Promise((resolve2) => {
+    execFile("ps", ["-A", "-o", "pid=,lstart="], { encoding: "utf8", timeout: 2e3, windowsHide: true }, (err, text) => {
+      const out = /* @__PURE__ */ new Map();
+      if (!err)
+        for (const line of text.split("\n")) {
+          const m = /^\s*(\d+)\s*(.*)$/.exec(line);
+          if (m)
+            out.set(Number(m[1]), m[2].trim());
+        }
+      resolve2(out);
+    });
+  });
+}
+var TREE_KILL_AFTER_MS = 5e3;
+function killProcessTree(child, signal = "SIGTERM") {
+  const pid = child.pid;
+  if (pid === void 0)
+    return;
+  if (process.platform === "win32" || signal === "SIGKILL") {
+    stopProcessGroup(child, signal === "SIGKILL" ? "SIGKILL" : "SIGTERM");
+    return;
+  }
+  const ended = () => child.exitCode !== null || child.signalCode !== null;
+  const send = (pids, s) => {
+    try {
+      process.kill(-pid, s);
+    } catch {
+    }
+    for (const p of pids)
+      try {
+        process.kill(p, s);
+      } catch {
+      }
+  };
+  void processDescendants(pid).then((first) => {
+    send([...first.keys(), ...ended() ? [] : [pid]], "SIGTERM");
+    let hardDone = false;
+    const hard = async () => {
+      if (hardDone)
+        return;
+      hardDone = true;
+      const now = await processesNow();
+      const still = [...first].filter(([p, start]) => now.get(p) === start).map(([p]) => p);
+      send([...still, ...ended() ? [] : [pid]], "SIGKILL");
+    };
+    const timer = setTimeout(() => void hard(), TREE_KILL_AFTER_MS);
+    timer.unref?.();
+    if (ended()) {
+      clearTimeout(timer);
+      void hard();
+    } else
+      child.once("exit", () => {
+        clearTimeout(timer);
+        void hard();
+      });
+  });
+}
+
+// packages/core/dist/run-log.js
+import { createHash, randomBytes as randomBytes2 } from "node:crypto";
+import { accessSync, appendFileSync as appendFileSync2, closeSync, constants as fsConstants, existsSync as existsSync2, fstatSync, lstatSync, mkdirSync as mkdirSync2, openSync, readdirSync, readFileSync as readFileSync2, readSync, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { hostname as hostname2 } from "node:os";
+import { join as join3 } from "node:path";
+var RUN_LOG_KEEP = 50;
+var RUN_LOG_MAX_BYTES = 2 * 1024 * 1024;
+var RUN_LOG_LINE_MAX = 4e3;
+var RUN_LOG_READ_MAX = 5e3;
+var RUN_HEARTBEAT_MS = 3e4;
+var RUN_SILENT_MS = 5 * 60 * 1e3;
+var TERMINAL_RUN_ID = /^\d{8}-\d{6}-\d{1,10}-[0-9a-f]{4}$/;
+var runLogsDirOf = (root) => join3(root, ".atticus", "logs", "runs");
+var runningDirOf = (root) => join3(root, ".atticus", "logs", "running");
+var all = true;
+var only = (...c) => new Set(c);
+var but = (...c) => ({ except: new Set(c) });
+var RECORDED = {
+  // The long ones.
+  map: all,
+  scan: all,
+  verify: all,
+  upgrade: all,
+  reconcile: all,
+  "run-ready": all,
+  workspace: only("sync", "bring-in", "open", "prune"),
+  task: but("context"),
+  knowledge: only("scan", "find", "ask", "keep", "verify", "correct", "reject"),
+  handoff: only("done"),
+  index: only("rebuild", "embed"),
+  // A change, from its start to its archive, and what it asks of people.
+  change: but("status", "list", "knowledge", "similar", "impact", "conflicts", "estimate", "map"),
+  initiative: but("status"),
+  questions: but("list", "show", "proposed", "decisions"),
+  critic: all,
+  finding: all,
+  plan: all,
+  stories: all,
+  needs: only("done", "skip", "reopen"),
+  todo: only("done", "run"),
+  ado: all,
+  release: all,
+  outcome: only("record"),
+  tests: only("generate"),
+  spec: only("draft", "seed", "accept", "hand-down", "hand-up"),
+  feature: but("list", "show"),
+  triage: only("decide"),
+  alias: all,
+  // The estate, the org pack and what Atticus learns.
+  baseline: all,
+  repo: all,
+  "repo-type": only("new", "note", "rules"),
+  rules: only("add", "activate", "off", "draft", "try", "import"),
+  types: only("add"),
+  skills: only("import", "write"),
+  connect: all,
+  join: all,
+  estate: only("join", "measure", "shared", "contracts"),
+  sources: only("sync", "tag", "refresh"),
+  glossary: only("scan", "define", "link", "alias"),
+  intake: only("add", "traffic"),
+  patterns: only("scan"),
+  defences: only("scan"),
+  onboard: but("check"),
+  frameworks: all,
+  dialect: only("new", "kit"),
+  plugin: all,
+  absorb: all,
+  orgpack: only("draft", "accept", "owner"),
+  standards: all,
+  openspec: only("setup"),
+  templates: only("draft"),
+  // ADR 0195: the build's commands write the catalog and its slots; the cross-check its dismissals.
+  catalog: only("migrate", "build", "edits", "undo", "prune", "crosscheck"),
+  diagram: all,
+  "assistant-files": all,
+  site: only("build"),
+  init: all,
+  adopt: all,
+  unadopt: all,
+  support: only("bundle"),
+  probe: all,
+  eval: only("run"),
+  bench: all
+};
+var NOT_RECORDED_FLAGS = /* @__PURE__ */ new Set(["help", "version", "check", "dry-run"]);
+var QUICK = /* @__PURE__ */ new Set(["map render", "verify audit", "scan review", "critic stats"]);
+var WRITES_WITH = {
+  "catalog edits": ["curate"],
+  "catalog undo": ["yes"],
+  "catalog prune": ["yes"],
+  "catalog crosscheck": ["dismiss", "undismiss", "promote"]
+};
+function recordedCommand(positionals, flags) {
+  const [group, command] = positionals;
+  if (!group || flags.some((f) => NOT_RECORDED_FLAGS.has(f)))
+    return false;
+  if (command && QUICK.has(`${group} ${command}`))
+    return false;
+  const writes = command ? WRITES_WITH[`${group} ${command}`] : void 0;
+  if (writes && !flags.some((f) => writes.includes(f)))
+    return false;
+  const rule = RECORDED[group];
+  if (rule === void 0)
+    return false;
+  if (rule === true)
+    return true;
+  if (!command)
+    return false;
+  return rule instanceof Set ? rule.has(command) : !rule.except.has(command);
+}
+var MAX_WORDS = 8;
+var WHERE_FLAGS = /* @__PURE__ */ new Set(["root", "metarepo"]);
+var TITLE_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "area",
+  "audience",
+  "base",
+  "by",
+  "change",
+  "component",
+  "depth",
+  "epic",
+  "estate",
+  "format",
+  "framework",
+  "gate",
+  "group",
+  "hops",
+  "iteration",
+  "journey",
+  "kind",
+  "language",
+  "lens",
+  "level",
+  "limit",
+  "mode",
+  "model",
+  "models",
+  "owner",
+  "platform",
+  "pr",
+  "release",
+  "repo",
+  "repos",
+  "round",
+  "run",
+  "scope",
+  "state",
+  "step",
+  "story",
+  "system",
+  "tag",
+  "target",
+  "task",
+  "team",
+  "template",
+  "type"
+]);
+var TITLE_VALUE_MAX = 48;
+var HANDLE = /^@[\w.-]+$/;
+var LONG_RUN = /[0-9a-f]{16,}|[0-9A-F]{16,}|\d{9,}|\d{4}(?:[ -]?\d{4}){3}|\b\d{3}-\d{2}-\d{4}\b/;
+var WORK_ITEM_SYSTEMS = ["ado", "jira"];
+var WORK_ITEM_REF = new RegExp(`^(?:${WORK_ITEM_SYSTEMS.join("|")}):(?:\\d{1,7}|[A-Z][A-Z0-9]{1,9}-\\d{1,7})$`);
+var ID_FORMS = [
+  /^\d{4}-\d{2}-\d{2}$/,
+  /^v?\d{1,3}\.\d{1,3}\.\d{1,3}(?:-[a-z]{1,12}(?:\.\d{1,3})?)?$/,
+  /^\d{1,3}(?:\.\d{1,3}){1,2}$/,
+  /^q-[0-9a-f]{1,12}$/,
+  /^run-\d{14}-(?:\d{4}|[0-9a-f]{6})$/,
+  TERMINAL_RUN_ID,
+  /^[a-z]{1,24}(?:[-.](?:[a-z]{1,24}\d{0,3}|\d{1,4}))+$/,
+  WORK_ITEM_REF
+];
+var LINK_REF = /^link:([^:]+):([^:]+)$/;
+var PART = /^(?:[a-z]{1,24}\d{0,3}|[A-Z][a-z]{1,23}|[A-Z]{1,8}|\d{1,6})$/;
+function idShaped(w) {
+  if (!w || w.length > 100)
+    return false;
+  if (!w.split(/[-._/]/).every((p) => PART.test(p)))
+    return false;
+  return (w.match(/\d+/g) ?? []).length <= 1;
+}
+function titleWord(word, redact2 = {}) {
+  if (!word || word.length > 100 || /[\s\\]/.test(word) || word.includes("//"))
+    return void 0;
+  const handle = HANDLE.test(word);
+  if (word.includes("@") && !handle)
+    return void 0;
+  if (hasTokenPrefix(word) || hasSecretShape(word))
+    return void 0;
+  if (redactText(word, redact2) !== word)
+    return void 0;
+  const bare = handle ? word.slice(1) : word;
+  if (ID_FORMS.some((re) => re.test(bare)))
+    return word;
+  const link2 = LINK_REF.exec(bare);
+  if (link2)
+    return idShaped(link2[1]) && idShaped(link2[2]) ? word : void 0;
+  if (bare.includes(":") || LONG_RUN.test(bare) || keyIsSecret(bare))
+    return void 0;
+  return idShaped(bare) ? word : void 0;
+}
+function titleValue(flag, value, redact2 = {}) {
+  if (value === void 0 || !value || !TITLE_VALUE_FLAGS.has(flag))
+    return void 0;
+  if (value.includes(":") || value.startsWith("-") || value.length > 400)
+    return void 0;
+  if (!value.split(",").every((i) => titleWord(i, redact2) !== void 0))
+    return void 0;
+  if (hasSecretShape(value) || keyIsSecret(value))
+    return void 0;
+  return value.length > TITLE_VALUE_MAX ? `${value.slice(0, TITLE_VALUE_MAX)}\u2026` : value;
+}
+function runTitle(positionals, flags, values = {}, redact2 = {}) {
+  const command = [];
+  const add = (w) => {
+    if (w !== "\u2026" || command.at(-1) !== "\u2026")
+      command.push(w);
+  };
+  for (const w of positionals.slice(0, MAX_WORDS))
+    add(titleWord(w, redact2) ?? "\u2026");
+  if (positionals.length > MAX_WORDS)
+    add("\u2026");
+  const names = flags.filter((f) => /^[a-z][a-z0-9-]{0,40}$/.test(f) && !WHERE_FLAGS.has(f)).map((f) => {
+    const v = Object.hasOwn(values, f) ? titleValue(f, values[f], redact2) : void 0;
+    return v === void 0 ? `--${f}` : `--${f} ${v}`;
+  });
+  if (flags.includes("\u2026"))
+    names.push("--\u2026");
+  return { command, title: ["atticus", ...command, ...names].join(" ") };
+}
+var APP_JOB_WORDS = {
+  scan: "Scan",
+  sync: "Sync",
+  reconcile: "Reconcile",
+  index: "Index",
+  intake: "Intake",
+  step: "AI step",
+  local: "Local step",
+  work: "Request"
+};
+function appRunTitle(kind, ids = [], redact2 = {}) {
+  const kept = [];
+  for (const id of ids.slice(0, MAX_WORDS)) {
+    const w = titleWord(id, redact2) ?? "\u2026";
+    if (w !== "\u2026" || kept.at(-1) !== "\u2026")
+      kept.push(w);
+  }
+  if (ids.length > MAX_WORDS && kept.at(-1) !== "\u2026")
+    kept.push("\u2026");
+  const words = Object.hasOwn(APP_JOB_WORDS, kind) ? APP_JOB_WORDS[kind] : "Job";
+  return { title: [words, ...kept].join(" "), ids: kept };
+}
+function runLogKept(root, env = process.env) {
+  if (env.ATTICUS_RUN_LOG === "off")
+    return false;
+  return isMetarepoRoot(root);
+}
+function isMetarepoRoot(root) {
+  return existsSync2(join3(root, "org-pack")) || existsSync2(join3(root, ".atticus", "org-pack"));
+}
+var RETITLED_MARK = ".retitled-beta27";
+var RETITLE_MAX_BYTES = 1024 * 1024;
+var RETITLE_MAX_RECORDS = 1e3;
+var RETITLE_WAIT_MS = 7 * 24 * 60 * 60 * 1e3;
+var retitleTried = /* @__PURE__ */ new Set();
+function readSmallFile(file, max) {
+  const before = lstatSync(file, { throwIfNoEntry: false });
+  if (!before?.isFile() || before.size > max)
+    return void 0;
+  const fd = openSync(file, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0) | (fsConstants.O_NONBLOCK ?? 0));
+  try {
+    const st = fstatSync(fd);
+    if (!st.isFile() || st.size > max)
+      return void 0;
+    const buf = Buffer.alloc(st.size);
+    let at = 0;
+    while (at < buf.length) {
+      const n = readSync(fd, buf, at, buf.length - at, at);
+      if (n <= 0)
+        break;
+      at += n;
+    }
+    return buf.subarray(0, at).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+function retitleTerminalRuns(root, retitle) {
+  const dir = runningDirOf(root);
+  const mark = join3(dir, RETITLED_MARK);
+  if (retitleTried.has(dir))
+    return 0;
+  let names;
+  try {
+    if (lstatSync(mark, { throwIfNoEntry: false }))
+      return 0;
+    if (!lstatSync(dir, { throwIfNoEntry: false })?.isDirectory())
+      return 0;
+    accessSync(dir, fsConstants.W_OK);
+    names = readdirSync(dir).filter((n) => n.endsWith(".json") && TERMINAL_RUN_ID.test(n.slice(0, -5))).sort().slice(-RETITLE_MAX_RECORDS);
+  } catch {
+    return 0;
+  }
+  let changed = 0;
+  let later = false;
+  const here = hostHash();
+  const now = Date.now();
+  const settling = (file) => {
+    try {
+      const st = lstatSync(file, { throwIfNoEntry: false });
+      return !!st?.isFile() && st.size <= RETITLE_MAX_BYTES && Math.abs(now - st.mtimeMs) <= RETITLE_WAIT_MS;
+    } catch {
+      return false;
+    }
+  };
+  for (const n of names) {
+    const file = join3(dir, n);
+    const id = n.slice(0, -5);
+    try {
+      const text = readSmallFile(file, RETITLE_MAX_BYTES);
+      if (text === void 0) {
+        if (settling(file))
+          later = true;
+        continue;
+      }
+      const raw = JSON.parse(text);
+      if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        continue;
+      if (raw.state === "running") {
+        const r = readRecord(root, id);
+        if (r && !goneRun(r, here, pidAlive, now, root)) {
+          later = true;
+          continue;
+        }
+      }
+      const words = Array.isArray(raw.command) ? raw.command.map((w) => `${w}`) : [];
+      if (raw.startedBy === "app" && !words.length) {
+        const job = raw.job && typeof raw.job === "object" ? raw.job : {};
+        const kind = typeof job.kind === "string" ? job.kind : "";
+        const ids = Array.isArray(job.ids) ? job.ids.map((w) => `${w}`) : [];
+        const got2 = appRunTitle(kind, ids);
+        const next2 = {
+          ...raw,
+          title: got2.title,
+          command: [],
+          ...raw.job && typeof raw.job === "object" ? { job: { ...job, ...got2.ids.length ? { ids: got2.ids } : {} } } : {}
+        };
+        if (!got2.ids.length && next2.job)
+          delete next2.job.ids;
+        if (JSON.stringify(next2) === JSON.stringify(raw))
+          continue;
+        writeJson(file, next2);
+        changed++;
+        continue;
+      }
+      if (words[0] === "secret" || words[0] === "legacy" && words[1] === "secret") {
+        try {
+          rmSync2(join3(runLogsDirOf(root), `${id}.log`), { force: true });
+          rmSync2(file, { force: true });
+          changed++;
+        } catch {
+          later = true;
+        }
+        continue;
+      }
+      if (typeof raw.title !== "string")
+        continue;
+      const flags = Array.isArray(raw.flags) ? raw.flags.map((f) => `${f}`) : [];
+      const got = retitle({ command: words, flags });
+      const next = { ...raw, title: got.title, command: got.command };
+      if (got.flags)
+        next.flags = got.flags;
+      if (JSON.stringify(next) === JSON.stringify(raw))
+        continue;
+      writeJson(file, next);
+      changed++;
+    } catch {
+      if (settling(file))
+        later = true;
+    }
+  }
+  if (later)
+    return changed;
+  try {
+    writeFileSync2(mark, `${(/* @__PURE__ */ new Date()).toISOString()}
+`, { encoding: "utf8", flag: "wx" });
+  } catch {
+    retitleTried.add(dir);
+  }
+  return changed;
+}
+function startedByOf(env = process.env) {
+  if (env.ATTICUS_ACP_SESSION)
+    return "copilot";
+  const said = env.ATTICUS_STARTED_BY;
+  if (said === "vscode" || said === "intellij" || said === "terminal")
+    return said;
+  if (env.TERM_PROGRAM === "vscode")
+    return "vscode";
+  if ((env.TERMINAL_EMULATOR ?? "").startsWith("JetBrains"))
+    return "intellij";
+  return "terminal";
+}
+var hostHash = () => {
+  try {
+    return createHash("sha256").update(hostname2()).digest("hex").slice(0, 12);
+  } catch {
+    return "unknown";
+  }
+};
+function procStartOf(pid) {
+  if (process.platform !== "linux")
+    return void 0;
+  try {
+    const stat2 = readFileSync2(`/proc/${pid}/stat`, "utf8");
+    const v = stat2.slice(stat2.lastIndexOf(")") + 2).split(" ")[19];
+    return v && /^\d+$/.test(v) ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var pad = (n, w = 2) => String(n).padStart(w, "0");
+var idAt = (d, pid) => `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}-${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}-${pid}-${randomBytes2(2).toString("hex")}`;
+var ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007]*\u0007/g;
+function runLogLines(text, o = {}) {
+  return text.replace(ANSI, "").split(/\r?\n|\r/).map((l) => {
+    const r = maskSecretShapes(redactText(l, o));
+    return r.length > RUN_LOG_LINE_MAX ? `${r.slice(0, RUN_LOG_LINE_MAX)}\u2026` : r;
+  });
+}
+var writeJson = (file, v) => {
+  const text = `${JSON.stringify(v, null, 2)}
+`;
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    rmSync2(tmp, { force: true });
+    writeFileSync2(tmp, text, { encoding: "utf8", flag: "wx" });
+    renameSync2(tmp, file);
+  } catch {
+    rmSync2(tmp, { force: true });
+    if (lstatSync(file, { throwIfNoEntry: false })?.isSymbolicLink())
+      return;
+    writeFileSync2(file, text, "utf8");
+  }
+};
+function prune(root, keep, live2) {
+  let names;
+  try {
+    names = readdirSync(runningDirOf(root)).filter((n) => n.endsWith(".json") && TERMINAL_RUN_ID.test(n.slice(0, -5))).sort();
+  } catch {
+    return;
+  }
+  const removed = /* @__PURE__ */ new Set();
+  let over = names.length - keep;
+  for (const n of names) {
+    if (over <= 0)
+      break;
+    const id = n.slice(0, -5);
+    if (live2(id))
+      continue;
+    rmSync2(join3(runningDirOf(root), n), { force: true });
+    rmSync2(join3(runLogsDirOf(root), `${id}.log`), { force: true });
+    removed.add(id);
+    over--;
+  }
+  try {
+    const kept = new Set(names.map((n) => n.slice(0, -5)).filter((id) => !removed.has(id)));
+    for (const n of readdirSync(runLogsDirOf(root)))
+      if (n.endsWith(".log") && TERMINAL_RUN_ID.test(n.slice(0, -4)) && !kept.has(n.slice(0, -4)))
+        rmSync2(join3(runLogsDirOf(root), n), { force: true });
+  } catch {
+  }
+}
+function startTerminalRun(root, o) {
+  const now = o.now ?? (() => /* @__PURE__ */ new Date());
+  const pid = o.pid ?? process.pid;
+  const keep = Math.max(o.keep ?? RUN_LOG_KEEP, 1);
+  const maxBytes = Math.max(o.maxBytes ?? RUN_LOG_MAX_BYTES, 256);
+  const started = now();
+  let runId = idAt(started, pid);
+  for (let n = 0; n < 8 && existsSync2(join3(runningDirOf(root), `${runId}.json`)); n++)
+    runId = idAt(started, pid);
+  const heartbeatMs = o.heartbeatMs ?? (o.hookProcess ? RUN_HEARTBEAT_MS : void 0);
+  const procStart = o.procStart ? o.procStart() : pid === process.pid ? procStartOf(pid) : void 0;
+  const app = o.app && !o.app.command ? appRunTitle(o.app.job.kind, o.app.ids, o.redact) : void 0;
+  const { command, title } = app ? { command: [], title: app.title } : runTitle(o.positionals, o.flags, o.values, o.redact);
+  const rec = {
+    schemaVersion: 1,
+    runId,
+    pid,
+    host: hostHash(),
+    title,
+    command,
+    flags: o.flags.filter((f) => /^[a-z][a-z0-9-]{0,40}$/.test(f)),
+    startedBy: o.app ? "app" : startedByOf(o.env),
+    startedAt: started.toISOString(),
+    state: "running",
+    lines: 0,
+    dropped: 0,
+    ...procStart ? { procStart } : {},
+    ...heartbeatMs ? { beatAt: started.toISOString() } : {},
+    ...o.app ? {
+      job: {
+        id: o.app.job.id,
+        kind: o.app.job.kind,
+        ...app?.ids.length ? { ids: app.ids } : {}
+      }
+    } : {}
+  };
+  const jsonFile = join3(runningDirOf(root), `${runId}.json`);
+  const logFile = join3(runLogsDirOf(root), `${runId}.log`);
+  try {
+    mkdirSync2(runningDirOf(root), { recursive: true });
+    mkdirSync2(runLogsDirOf(root), { recursive: true });
+    ignoreLocalSync(root);
+    const alive2 = o.alive ?? pidAlive;
+    prune(root, keep - 1, (id) => {
+      const r = readRecord(root, id);
+      return !!r && r.state === "running" && !goneRun(r, rec.host, alive2, now().getTime(), root);
+    });
+    writeFileSync2(logFile, "", "utf8");
+    writeJson(jsonFile, rec);
+  } catch {
+    return void 0;
+  }
+  let bytes = 0;
+  let inFile = 0;
+  let ended = false;
+  let broken = false;
+  const save = () => {
+    try {
+      if (heartbeatMs && !ended)
+        rec.beatAt = now().toISOString();
+      writeJson(jsonFile, { ...rec, lines: rec.dropped + inFile });
+    } catch {
+    }
+  };
+  const trim = () => {
+    const all2 = readFileSync2(logFile, "utf8").split("\n");
+    if (all2.at(-1) === "")
+      all2.pop();
+    let size = 0;
+    let at = all2.length;
+    while (at > 0 && size + Buffer.byteLength(all2[at - 1]) + 1 <= maxBytes / 2) {
+      size += Buffer.byteLength(all2[at - 1]) + 1;
+      at--;
+    }
+    const kept = all2.slice(at);
+    const tmp = `${logFile}.${process.pid}.tmp`;
+    const text = kept.length ? `${kept.join("\n")}
+` : "";
+    try {
+      writeFileSync2(tmp, text, "utf8");
+      renameSync2(tmp, logFile);
+    } catch {
+      rmSync2(tmp, { force: true });
+      writeFileSync2(logFile, text, "utf8");
+    }
+    rec.dropped += at;
+    inFile = kept.length;
+    bytes = size;
+    save();
+  };
+  const unhook2 = [];
+  if (heartbeatMs) {
+    const beat = setInterval(() => {
+      if (!ended)
+        save();
+    }, heartbeatMs);
+    beat.unref?.();
+    unhook2.push(() => clearInterval(beat));
+  }
+  const recorder = {
+    runId,
+    line(text) {
+      if (ended || broken)
+        return;
+      try {
+        for (const l of runLogLines(text, o.redact)) {
+          const s = `${l}
+`;
+          const n = Buffer.byteLength(s);
+          if (bytes + n > maxBytes)
+            trim();
+          appendFileSync2(logFile, s, "utf8");
+          bytes += n;
+          inFile++;
+        }
+      } catch {
+        broken = true;
+      }
+    },
+    end(code, how) {
+      if (ended)
+        return;
+      ended = true;
+      for (const u of unhook2)
+        u();
+      rec.state = how === "crash" ? "failed" : code === 0 ? "done" : code === 130 || code === 143 ? "cancelled" : "failed";
+      rec.exitCode = code;
+      if (how === "app-closed")
+        rec.appClosed = true;
+      rec.finishedAt = now().toISOString();
+      save();
+    }
+  };
+  if (o.hookProcess) {
+    const onExit2 = (code) => recorder.end(typeof code === "number" ? code : 1);
+    process.once("exit", onExit2);
+    unhook2.push(() => process.off("exit", onExit2));
+    for (const [sig, code] of [
+      ["SIGINT", 130],
+      ["SIGTERM", 143]
+    ]) {
+      const on = () => {
+        if (atticusHandles(sig, on) || stopPending())
+          return;
+        recorder.end(code);
+        process.exit(code);
+      };
+      unhook2.push(onAtticusSignal(sig, on, { fallback: true }));
+    }
+  }
+  return recorder;
+}
+function startAppRun(root, o) {
+  return startTerminalRun(root, {
+    positionals: o.command?.positionals ?? [],
+    flags: o.command?.flags ?? [],
+    ...o.command?.values ? { values: o.command.values } : {},
+    app: { job: o.job, ...o.ids ? { ids: o.ids } : {}, ...o.command ? { command: true } : {} },
+    heartbeatMs: o.heartbeatMs ?? RUN_HEARTBEAT_MS,
+    ...o.now ? { now: o.now } : {},
+    ...o.redact ? { redact: o.redact } : {}
+  });
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+var DAY = 24 * 60 * 60 * 1e3;
+var mtimeOf = (file) => {
+  try {
+    return statSync2(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+};
+function goneRun(r, here, alive2, now, root, startOf = procStartOf) {
+  const age = now - Date.parse(r.startedAt);
+  if (r.host !== here)
+    return age > 2 * DAY;
+  if (!alive2(r.pid) || age > 7 * DAY)
+    return true;
+  const started = r.procStart ? startOf(r.pid) : void 0;
+  if (started !== void 0)
+    return started !== r.procStart;
+  if (r.beatAt) {
+    const last = Math.max(Date.parse(r.beatAt) || 0, mtimeOf(join3(runLogsDirOf(root), `${r.runId}.log`)));
+    return now - last > RUN_SILENT_MS;
+  }
+  return false;
+}
+function readRecord(root, runId) {
+  if (!TERMINAL_RUN_ID.test(runId))
+    return void 0;
+  try {
+    const r = JSON.parse(readFileSync2(join3(runningDirOf(root), `${runId}.json`), "utf8"));
+    if (r.schemaVersion !== 1 || r.runId !== runId || typeof r.title !== "string" || typeof r.startedAt !== "string" || typeof r.pid !== "number" || !["running", "done", "failed", "cancelled"].includes(r.state))
+      return void 0;
+    const { job, appClosed, ...rest } = r;
+    const jobOk = !!job && typeof job === "object" && typeof job.id === "string" && typeof job.kind === "string";
+    return {
+      ...rest,
+      command: Array.isArray(r.command) ? r.command.map(String) : [],
+      flags: Array.isArray(r.flags) ? r.flags.map(String) : [],
+      lines: Number(r.lines) || 0,
+      dropped: Number(r.dropped) || 0,
+      ...typeof r.procStart === "string" ? { procStart: r.procStart } : {},
+      ...typeof r.beatAt === "string" ? { beatAt: r.beatAt } : {},
+      ...jobOk ? { job: { id: job.id, kind: job.kind } } : {},
+      ...appClosed === true ? { appClosed: true } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function readTerminalRuns(root, o = {}) {
+  let names;
+  try {
+    names = readdirSync(runningDirOf(root));
+  } catch {
+    return [];
+  }
+  const here = hostHash();
+  const alive2 = o.alive ?? pidAlive;
+  const now = (o.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+  const out = [];
+  for (const n of names.sort().reverse()) {
+    if (!n.endsWith(".json"))
+      continue;
+    const r = readRecord(root, n.slice(0, -5));
+    if (!r)
+      continue;
+    if (r.state === "running") {
+      if (goneRun(r, here, alive2, now, root, o.startOf)) {
+        out.push({ ...r, stale: true });
+        continue;
+      }
+    }
+    out.push(r);
+  }
+  return out;
+}
+var readTerminalRun = (root, runId, o = {}) => TERMINAL_RUN_ID.test(runId) ? readTerminalRuns(root, o).find((r) => r.runId === runId) : void 0;
+function readTerminalRunLines(root, runId, from, max = RUN_LOG_READ_MAX) {
+  const r = readRecord(root, runId);
+  if (!r)
+    return void 0;
+  let text;
+  try {
+    text = readFileSync2(join3(runLogsDirOf(root), `${runId}.log`), "utf8");
+  } catch {
+    text = "";
+  }
+  const all2 = text.split("\n");
+  all2.pop();
+  const total = r.dropped + all2.length;
+  const start = from === void 0 ? Math.max(total - max, r.dropped) : Math.max(Math.min(from, total), r.dropped);
+  const lines = all2.slice(start - r.dropped, start - r.dropped + max);
+  return { from: start, lines, total };
+}
+function linesIn(buf, skip, max) {
+  const lines = [];
+  let at = 0;
+  let n = 0;
+  while (at < buf.length) {
+    const nl = buf.indexOf(10, at);
+    if (nl < 0)
+      break;
+    if (n >= skip) {
+      if (lines.length >= max)
+        return { lines, end: at, more: true };
+      lines.push(buf.toString("utf8", at, nl));
+    }
+    n++;
+    at = nl + 1;
+  }
+  return { lines, end: at, more: false };
+}
+function readFrom(file, from, size) {
+  const buf = Buffer.alloc(Math.max(size - from, 0));
+  if (!buf.length)
+    return buf;
+  const fd = openSync(file, "r");
+  try {
+    let got = 0;
+    while (got < buf.length) {
+      const n = readSync(fd, buf, got, buf.length - got, from + got);
+      if (n <= 0)
+        break;
+      got += n;
+    }
+    return got < buf.length ? buf.subarray(0, got) : buf;
+  } finally {
+    closeSync(fd);
+  }
+}
+function tailTerminalRunLines(root, runId, at, max = RUN_LOG_READ_MAX) {
+  const file = join3(runLogsDirOf(root), `${runId}.log`);
+  for (let tries = 0; ; tries++) {
+    const r = readRecord(root, runId);
+    if (!r)
+      return void 0;
+    let size = 0;
+    let ino = 0;
+    try {
+      const st = statSync2(file);
+      size = st.size;
+      ino = st.ino;
+    } catch {
+    }
+    if (at && at.dropped === r.dropped && at.ino === ino && size >= at.bytes) {
+      let buf2;
+      try {
+        buf2 = readFrom(file, at.bytes, size);
+      } catch {
+        buf2 = Buffer.alloc(0);
+      }
+      const got2 = linesIn(buf2, 0, max);
+      return {
+        from: at.line,
+        lines: got2.lines,
+        at: {
+          line: at.line + got2.lines.length,
+          bytes: at.bytes + got2.end,
+          dropped: r.dropped,
+          ino
+        },
+        more: got2.more
+      };
+    }
+    let buf;
+    try {
+      buf = readFileSync2(file);
+    } catch {
+      buf = Buffer.alloc(0);
+    }
+    const again = readRecord(root, runId);
+    if (again && again.dropped !== r.dropped && tries < 1)
+      continue;
+    let count = 0;
+    for (let i = buf.indexOf(10); i >= 0; i = buf.indexOf(10, i + 1))
+      count++;
+    const total = r.dropped + count;
+    const start = at === void 0 ? Math.max(total - max, r.dropped) : Math.max(Math.min(at.line, total), r.dropped);
+    const got = linesIn(buf, start - r.dropped, max);
+    return {
+      from: start,
+      lines: got.lines,
+      at: { line: start + got.lines.length, bytes: got.end, dropped: r.dropped, ino },
+      more: got.more
+    };
+  }
+}
+
+// packages/core/dist/printer.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var printer = new AsyncLocalStorage();
+function withPrinter(print, work) {
+  return printer.run(print, work);
+}
+function printToCurrent(line) {
+  const p = printer.getStore();
+  if (!p)
+    return;
+  try {
+    p(line);
+  } catch {
+  }
+}
+
+export {
+  fieldKey,
+  lineNamesRoute,
+  lineNamesWord,
+  lineNamesField,
+  lineNamesClaim,
+  claimOnLines,
+  normalizeQuote,
+  quoteMatches,
+  isBinaryPath,
+  quoteNotRequired,
+  isSecretPath,
+  TOKEN_PREFIXES,
+  hasTokenPrefix,
+  hasSecretShape,
+  maskSecretShapes,
+  keyIsSecret,
+  redactSecrets,
+  quoteHoldsSecret,
+  partsBuildWord,
+  partsNamePath,
+  declaresConventionalRoute,
+  pathPieceOnlyInComment,
+  writeFileAtomic,
+  FileChangedError,
+  writeFileIfUnchanged,
+  renameRetrying,
+  LockHeldError,
+  lockFileOf,
+  readLock,
+  acquireLock,
+  sharedLockFileOf,
+  QUICK_WRITE_LOCK,
+  withSharedFileLock,
+  LOCAL_ONLY,
+  ensureLocalIgnore,
+  LOG_MAX_BYTES,
+  LOG_KEEP,
+  logFileOf,
+  redactText,
+  redact,
+  logLevelFrom,
+  createLog,
+  ignoreLocalSync,
+  NO_LOG,
+  TREE_SIGNAL_GRACE_MS,
+  stopTrackedTrees,
+  onStopping,
+  onAtticusSignal,
+  atticusHandles,
+  stopPending,
+  trackTree,
+  holdStop,
+  trackedTrees,
+  stopProcessGroup,
+  processDescendants,
+  TREE_KILL_AFTER_MS,
+  killProcessTree,
+  RUN_LOG_KEEP,
+  RUN_LOG_MAX_BYTES,
+  RUN_LOG_LINE_MAX,
+  RUN_LOG_READ_MAX,
+  RUN_HEARTBEAT_MS,
+  RUN_SILENT_MS,
+  TERMINAL_RUN_ID,
+  runLogsDirOf,
+  runningDirOf,
+  recordedCommand,
+  TITLE_VALUE_FLAGS,
+  TITLE_VALUE_MAX,
+  WORK_ITEM_SYSTEMS,
+  titleWord,
+  titleValue,
+  runTitle,
+  APP_JOB_WORDS,
+  appRunTitle,
+  runLogKept,
+  isMetarepoRoot,
+  RETITLED_MARK,
+  RETITLE_MAX_BYTES,
+  retitleTerminalRuns,
+  startedByOf,
+  procStartOf,
+  runLogLines,
+  startTerminalRun,
+  startAppRun,
+  pidAlive,
+  readTerminalRuns,
+  readTerminalRun,
+  readTerminalRunLines,
+  tailTerminalRunLines,
+  withPrinter,
+  printToCurrent
+};