@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.3

package/dist/chunk-IQFTZ37C.js

@@ -0,0 +1,2919 @@
+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 {
+  findSection,
+  generateAssistantFiles,
+  loadOrgCommands,
+  parseHeader,
+  renderAssistantFiles,
+  writeAssistantFiles
+} from "./chunk-V5PKHHQQ.js";
+import {
+  BUILT_IN_CHECKS,
+  STARTER_REVIEW_PATH,
+  starterReviewText
+} from "./chunk-7UFQZXZA.js";
+import {
+  changeFootprint,
+  changeStore,
+  loadChangeContext
+} from "./chunk-56YQ6ROQ.js";
+import {
+  ORG_FLOW,
+  createOpenSpec,
+  setDefaultSchema,
+  storeIdOf,
+  writeOrgFlowSchema,
+  writeStoreMarker
+} from "./chunk-4AK7IBVP.js";
+import {
+  readCatalog
+} from "./chunk-OLWFG75W.js";
+import {
+  componentExtractor
+} from "./chunk-MC3H7736.js";
+import {
+  createGit,
+  ensureGitignore
+} from "./chunk-KJPMEAI4.js";
+import {
+  DEFAULT_IGNORES,
+  fsRepo,
+  memoryRepo,
+  runExtractor
+} from "./chunk-GQ4N4WKF.js";
+import {
+  ChangeLifecycle,
+  ChecklistPack,
+  ChecklistRule,
+  DEFAULT_CHANGE_TYPES,
+  DEFAULT_GATES,
+  DEFAULT_RUNTIME,
+  DEFAULT_SOURCES,
+  DEFAULT_TEST_STRATEGY,
+  RecordId,
+  RepoManifest,
+  SOURCES_SCHEMA_VERSION,
+  SkillMeta,
+  Sources,
+  loadOrgPack,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  LOCAL_ONLY
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/adopt/dist/errors.js
+var AdoptError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AdoptError";
+  }
+};
+
+// packages/adopt/dist/files.js
+import { createHash } from "node:crypto";
+import { cp, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+var toPosix = (p) => p.split(sep).join("/");
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDir(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function readText(path) {
+  try {
+    return (await readFile(path, "utf8")).replace(/\r\n/g, "\n");
+  } catch {
+    return void 0;
+  }
+}
+var sha256 = (data) => createHash("sha256").update(data).digest("hex");
+var WALK_SKIP = /* @__PURE__ */ new Set([".git", "node_modules"]);
+async function listFiles(dir, o = {}) {
+  const out = [];
+  const skipNames = o.skipNames ?? WALK_SKIP;
+  const skipPaths = new Set(o.skipPaths ?? []);
+  async function walk(abs) {
+    let entries;
+    try {
+      entries = await readdir(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isSymbolicLink())
+        continue;
+      const full = join(abs, e.name);
+      const rel = toPosix(relative(dir, full));
+      if (e.isDirectory()) {
+        if (!skipNames.has(e.name) && !skipPaths.has(rel))
+          await walk(full);
+      } else if (e.isFile())
+        out.push(rel);
+    }
+  }
+  await walk(dir);
+  return out.sort();
+}
+async function listDirs(dir, skipNames = WALK_SKIP) {
+  const out = [];
+  async function walk(abs) {
+    let entries;
+    try {
+      entries = await readdir(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.isSymbolicLink() || skipNames.has(e.name))
+        continue;
+      const full = join(abs, e.name);
+      out.push(toPosix(relative(dir, full)));
+      await walk(full);
+    }
+  }
+  await walk(dir);
+  return out.sort();
+}
+async function hashTree(dir, o = {}) {
+  const out = {};
+  for (const f of await listFiles(dir, o))
+    out[f] = sha256(await readFile(join(dir, f)));
+  return out;
+}
+async function writeNew(path, text2, keep = true) {
+  if (keep && await exists(path))
+    return false;
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, text2, "utf8");
+  return true;
+}
+async function copyDir(from, to) {
+  await cp(from, to, { recursive: true, force: false, errorOnExist: false });
+}
+function slug(s) {
+  const v = s.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").replace(/-+$/g, "").slice(0, 100).replace(/[-.]+$/, "");
+  return v || "item";
+}
+function frontMatter(text2) {
+  const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(text2.replace(/\r\n/g, "\n"));
+  return m ? { data: m[1], body: m[2] } : { data: void 0, body: text2 };
+}
+
+// packages/adopt/dist/layout.js
+var import_yaml = __toESM(require_dist(), 1);
+import { join as join2 } from "node:path";
+var ATTICUS_DIR = ".atticus";
+var ORG_PACK_DIR = "org-pack";
+var STATE_FOLDERS = ["workspace", ".index", ".runs", "state", "absorbed"];
+var LOCAL_STATE = [
+  ...STATE_FOLDERS,
+  ...LOCAL_ONLY.map((l) => l.endsWith("/") ? l.slice(0, -1) : l)
+];
+function isLocalState(rel, atRoot = false) {
+  const parts = rel.split("/");
+  const inside = parts[0] === ATTICUS_DIR;
+  if (!inside && !atRoot)
+    return false;
+  const at = inside ? 1 : 0;
+  const head = parts[at];
+  if (head === void 0 || parts.length <= at)
+    return false;
+  return LOCAL_STATE.includes(head) && (parts.length > at + 1 || head.includes("."));
+}
+async function readLayout(orgPackDir) {
+  const text2 = await readText(join2(orgPackDir, "sources.yaml"));
+  if (text2 === void 0)
+    return DEFAULT_SOURCES.layout;
+  try {
+    const r = Sources.safeParse((0, import_yaml.parse)(text2));
+    return r.success ? r.data.layout : DEFAULT_SOURCES.layout;
+  } catch {
+    return DEFAULT_SOURCES.layout;
+  }
+}
+async function resolveMetarepo(root) {
+  const adopted = !await isDir(join2(root, ORG_PACK_DIR)) && await isDir(join2(root, ATTICUS_DIR, ORG_PACK_DIR));
+  return pathsFor(root, adopted, await readLayout(orgPackDirOf(root, adopted)));
+}
+function orgPackDirOf(root, adopted) {
+  return adopted ? join2(root, ATTICUS_DIR, ORG_PACK_DIR) : join2(root, ORG_PACK_DIR);
+}
+function pathsFor(root, adopted, layout) {
+  const stateDir = adopted ? join2(root, ATTICUS_DIR) : root;
+  const proposalsRel = adopted ? `${ATTICUS_DIR}/proposals` : "proposals";
+  return {
+    root,
+    adopted,
+    orgPackDir: orgPackDirOf(root, adopted),
+    orgPackRel: adopted ? `${ATTICUS_DIR}/${ORG_PACK_DIR}` : ORG_PACK_DIR,
+    layout,
+    catalogDir: join2(root, ...layout.catalog.split("/")),
+    openspecDir: join2(root, ...layout.openspec.split("/")),
+    stateDir,
+    proposalsDir: join2(root, ...proposalsRel.split("/")),
+    proposalsRel,
+    inputsDir: adopted ? join2(root, ATTICUS_DIR, "inputs") : join2(root, "inputs")
+  };
+}
+function inPlacePath(url) {
+  if (url === ".")
+    return ".";
+  if (url.startsWith("./")) {
+    const rest = url.slice(2).replace(/\/+$/, "");
+    if (rest === "")
+      return ".";
+    if (rest.split("/").includes(".."))
+      return void 0;
+    return rest;
+  }
+  return void 0;
+}
+
+// packages/adopt/dist/detect.js
+var REPO_TYPES = [
+  "spring-boot",
+  "java",
+  "frontend",
+  "node",
+  "python",
+  "go",
+  "dotnet",
+  "gateway",
+  "mainframe",
+  "infra",
+  "event-config",
+  "unknown"
+];
+var FRONTEND_DEPS = ["react", "vue", "@angular/core", "svelte", "next", "nuxt", "solid-js"];
+async function first(repo, globs) {
+  for await (const p of repo.listFiles(globs))
+    return p;
+  return void 0;
+}
+async function all(repo, globs, max = 3) {
+  const out = [];
+  for await (const p of repo.listFiles(globs)) {
+    out.push(p);
+    if (out.length >= max)
+      break;
+  }
+  return out;
+}
+async function marker(repo, names) {
+  const root = await first(repo, names);
+  if (root)
+    return root;
+  const deep = [];
+  for await (const p of repo.listFiles(names.map((n) => `**/${n}`)))
+    deep.push(p);
+  return deep.sort((a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b))[0];
+}
+async function text(repo, path) {
+  try {
+    return await repo.readText(path);
+  } catch {
+    return "";
+  }
+}
+var TYPE_WORDS = [
+  ["gateway", ["api gateway", "gateway", "api proxy", "reverse proxy"]],
+  ["infra", ["infrastructure", "terraform", "kubernetes manifests", "helm chart", "deployment"]],
+  ["event-config", ["topic definitions", "event topics", "topic config", "event catalogue"]],
+  ["mainframe", ["mainframe", "cobol", "batch jobs"]],
+  ["frontend", ["web app", "single-page app", "front end", "frontend", "the pages"]]
+];
+function typeFromDescription(text2) {
+  const t = (text2 ?? "").toLowerCase();
+  if (!t)
+    return void 0;
+  for (const [type, words] of TYPE_WORDS)
+    if (words.some((w) => t.includes(w)))
+      return type;
+  return void 0;
+}
+var TYPE_OF_FRAMEWORK = [
+  ["spring-boot", "spring-boot"],
+  ["spring", "spring-boot"],
+  ["quarkus", "java"],
+  ["micronaut", "java"],
+  ["hibernate", "java"],
+  ["asp.net", "dotnet"],
+  ["entity-framework", "dotnet"],
+  ["angular", "frontend"],
+  ["react", "frontend"],
+  ["vue", "frontend"],
+  ["svelte", "frontend"],
+  ["next", "frontend"],
+  ["express", "node"],
+  ["nest", "node"],
+  ["typeorm", "node"],
+  ["prisma", "node"],
+  ["django", "python"],
+  ["django-rest-framework", "python"],
+  ["flask", "python"],
+  ["fastapi", "python"],
+  ["celery", "python"]
+];
+function typeFromFrameworks(declared) {
+  for (const [name, type] of TYPE_OF_FRAMEWORK) {
+    const hit = declared.filter((d) => d.name.trim().toLowerCase() === name);
+    if (hit.length)
+      return { type, signals: hit.map((d) => d.cite) };
+  }
+  return void 0;
+}
+async function detectRepoType(repo, o = {}) {
+  const comp = await runExtractor(componentExtractor, repo, {
+    scannedAt: "1970-01-01T00:00:00Z"
+  });
+  const component = comp.records.some((r) => r.kind === "Component");
+  const d = (type, signals, confidence) => ({
+    type,
+    signals,
+    component,
+    confidence
+  });
+  const apigeeFirst = await all(repo, ["**/apiproxy/*.xml", "**/apiproxy/proxies/*.xml"]);
+  const declared = apigeeFirst.length ? void 0 : typeFromFrameworks(o.frameworks ?? []);
+  if (declared)
+    return d(declared.type, declared.signals, "high");
+  const apigee = apigeeFirst;
+  const kong = await first(repo, ["kong.yaml", "kong.yml", "**/kong.yaml", "**/kong.yml"]);
+  if (apigee.length || kong)
+    return d("gateway", apigee.length ? apigee : [kong], "high");
+  const pom = await marker(repo, ["pom.xml", "build.gradle", "build.gradle.kts"]);
+  const pkg = await marker(repo, ["package.json"]);
+  const py = await marker(repo, ["pyproject.toml", "requirements.txt", "setup.py"]);
+  const gomod = await marker(repo, ["go.mod"]);
+  const dotnet = await first(repo, ["*.csproj", "*.sln", "*.fsproj", "**/*.csproj"]);
+  const anyBuild = pom ?? pkg ?? py ?? gomod ?? dotnet;
+  const cobol = await all(repo, [
+    "**/*.cbl",
+    "**/*.CBL",
+    "**/*.cob",
+    "**/*.COB",
+    "**/*.jcl",
+    "**/*.JCL"
+  ]);
+  if (cobol.length && !anyBuild)
+    return d("mainframe", cobol, "high");
+  if (pom) {
+    const t = await text(repo, pom);
+    return /spring-boot|org\.springframework\.boot/.test(t) ? d("spring-boot", [pom], "high") : d("java", [pom], "medium");
+  }
+  if (pkg) {
+    let deps = {};
+    try {
+      const j = JSON.parse(await text(repo, pkg));
+      deps = { ...j.dependencies ?? {}, ...j.devDependencies ?? {} };
+    } catch {
+    }
+    const fe = FRONTEND_DEPS.find((n) => n in deps);
+    return fe ? d("frontend", [pkg], "high") : d("node", [pkg], "medium");
+  }
+  if (py)
+    return d("python", [py], "medium");
+  if (gomod)
+    return d("go", [gomod], "high");
+  if (dotnet)
+    return d("dotnet", [dotnet], "high");
+  const infra = await all(repo, [
+    "**/*.tf",
+    "**/k8s/**/*.yaml",
+    "**/k8s/**/*.yml",
+    "**/kubernetes/**/*.yaml",
+    "**/Chart.yaml",
+    "**/kustomization.yaml"
+  ]);
+  if (infra.length)
+    return d("infra", infra, "medium");
+  const topics = await all(repo, ["**/topics/*.yaml", "**/topics/*.yml", "**/topics/**/*.yaml"]);
+  if (topics.length)
+    return d("event-config", topics, "medium");
+  const said = typeFromDescription(o.description);
+  if (said)
+    return d(said, ["the repo's description in repos.manifest.yaml"], "low");
+  return d("unknown", [], "low");
+}
+
+// packages/adopt/dist/discover.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readdir as readdir2, realpath } from "node:fs/promises";
+import { basename, isAbsolute, join as join3, relative as relative2, resolve } from "node:path";
+var UNASSIGNED = "unassigned";
+var MockRepoListing = class {
+  orgs;
+  constructor(orgs) {
+    this.orgs = orgs;
+  }
+  async listRepos(org) {
+    const repos = this.orgs[org];
+    if (!repos)
+      throw new Error(`no organisation ${org} on the mock Git host`);
+    return repos.map(({ files: _f, ...r }) => r);
+  }
+  async openRepo(repo) {
+    for (const repos of Object.values(this.orgs)) {
+      const r = repos.find((x) => x.name === repo.name);
+      if (r)
+        return memoryRepo(r.name, "0000000", r.files);
+    }
+    throw new Error(`no repo ${repo.name} on the mock Git host`);
+  }
+};
+async function originUrl(dir) {
+  const cfg = await readText(join3(dir, ".git", "config"));
+  if (!cfg)
+    return void 0;
+  const m = /\[remote "origin"\][^[]*?url\s*=\s*(\S+)/.exec(cfg);
+  return m?.[1]?.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]+@/i, "$1");
+}
+async function headBranch(dir) {
+  const head = await readText(join3(dir, ".git", "HEAD"));
+  return head ? /^ref: refs\/heads\/(\S+)/.exec(head)?.[1] : void 0;
+}
+var SKIP_FOLDERS = /* @__PURE__ */ new Set([
+  ".git",
+  ".atticus",
+  ".github",
+  ".claude",
+  ".specify",
+  ".vscode",
+  ".idea",
+  "node_modules",
+  "workspace",
+  "openspec",
+  "org-pack",
+  "catalog",
+  "proposals",
+  "inputs",
+  "specs"
+]);
+var SELF_IGNORE = [".git", "node_modules", ".atticus", "openspec", "specs", ".specify"];
+async function hiddenAndNested(dir) {
+  const hidden = /* @__PURE__ */ new Set();
+  const nested = [];
+  const walk = async (abs, rel) => {
+    let entries;
+    try {
+      entries = await readdir2(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory())
+        continue;
+      if (e.name.startsWith(".")) {
+        hidden.add(e.name);
+        continue;
+      }
+      if (DEFAULT_IGNORES.includes(e.name))
+        continue;
+      const sub = join3(abs, e.name);
+      const path = rel ? `${rel}/${e.name}` : e.name;
+      if (await exists(join3(sub, ".git")))
+        nested.push(path);
+      else
+        await walk(sub, path);
+    }
+  };
+  await walk(dir, "");
+  return { hidden: [...hidden].sort(), nested: nested.sort() };
+}
+async function visibleRepo(name, dir, ignore = DEFAULT_IGNORES) {
+  const { hidden, nested } = await hiddenAndNested(dir);
+  const h = fsRepo(name, dir, "0000000", { ignore: [.../* @__PURE__ */ new Set([...ignore, ...hidden])] });
+  const shown = (p) => {
+    const folders = p.split("/").slice(0, -1);
+    return !folders.some((s) => s.startsWith(".") || s === "node_modules") && !nested.some((n) => p.startsWith(`${n}/`));
+  };
+  return {
+    name: h.name,
+    commit: h.commit,
+    async *listFiles(globs) {
+      for await (const p of h.listFiles(globs))
+        if (shown(p))
+          yield p;
+    },
+    readText: (p) => h.readText(p)
+  };
+}
+async function localCandidates(dir) {
+  const skipped = [];
+  const repos = [];
+  const builds = [];
+  const listed = (await readdir2(dir, { withFileTypes: true })).filter((e) => (e.isDirectory() || e.isSymbolicLink()) && !SKIP_FOLDERS.has(e.name) && !e.name.startsWith(".")).sort((a, b) => a.name < b.name ? -1 : 1);
+  const here = await realpath(dir);
+  const real = /* @__PURE__ */ new Map();
+  for (const e of listed)
+    if (e.isDirectory())
+      real.set(await realpath(join3(dir, e.name)), e.name);
+  const entries = [];
+  for (const e of listed) {
+    if (e.isDirectory()) {
+      entries.push(e.name);
+      continue;
+    }
+    const to = await realpath(join3(dir, e.name)).catch(() => void 0);
+    if (!to || !await isDir(to)) {
+      skipped.push({ path: e.name, reason: "a link to nothing" });
+      continue;
+    }
+    const up = relative2(to, here);
+    if (up === "" || !up.startsWith("..") && !isAbsolute(up)) {
+      skipped.push({ path: e.name, reason: "a link to this folder or one it is in" });
+      continue;
+    }
+    const had = real.get(to);
+    if (had) {
+      skipped.push({ path: e.name, reason: `a link to ${had}, which is read already` });
+      continue;
+    }
+    real.set(to, e.name);
+    entries.push(e.name);
+  }
+  const selfClone = await exists(join3(dir, ".git"));
+  for (const name of entries) {
+    const sub = join3(dir, name);
+    const repo = await visibleRepo(name, sub);
+    const isClone = await isDir(join3(sub, ".git"));
+    if (selfClone && !isClone && await exists(join3(sub, ".git"))) {
+      skipped.push({
+        path: name,
+        reason: "a git worktree (a checkout of another clone), not a repo"
+      });
+      continue;
+    }
+    const det = await detectRepoType(repo);
+    if (isClone)
+      repos.push({ dir: sub, repo });
+    else if (det.type !== "unknown" || det.component)
+      builds.push(name);
+    else
+      skipped.push({ path: name, reason: "no build file, code or platform files" });
+  }
+  skipped.sort((a, b) => a.path < b.path ? -1 : 1);
+  if (selfClone) {
+    const self = await visibleRepo(basename(resolve(dir)), dir, SELF_IGNORE);
+    return { repos: [{ dir, repo: self, modules: builds }, ...repos], skipped };
+  }
+  for (const name of builds)
+    repos.push({ dir: join3(dir, name), repo: await visibleRepo(name, join3(dir, name)) });
+  repos.sort((a, b) => basename(a.dir) < basename(b.dir) ? -1 : 1);
+  if (repos.length === 0) {
+    const self = await visibleRepo(basename(resolve(dir)), dir, SELF_IGNORE);
+    const det = await detectRepoType(self);
+    if (await isDir(join3(dir, ".git")) || det.type !== "unknown" || det.component)
+      return { repos: [{ dir, repo: self }], skipped: [] };
+  }
+  return { repos, skipped };
+}
+function questionsFor(entry, det) {
+  const q = [];
+  if (entry.owner === UNASSIGNED)
+    q.push({
+      repo: entry.id,
+      field: "owner",
+      question: `Which team owns ${entry.id}? Set owner in repos.manifest.yaml (a team id).`
+    });
+  if (!entry.system)
+    q.push({
+      repo: entry.id,
+      field: "system",
+      question: `Which system does ${entry.id} belong to? Set system in repos.manifest.yaml, or leave it out if the repo serves several.`
+    });
+  if (det.type === "unknown")
+    q.push({
+      repo: entry.id,
+      field: "type",
+      question: `What kind of repo is ${entry.id}? No build file or platform file told us; set type in repos.manifest.yaml.`
+    });
+  return q;
+}
+async function existingManifest(path) {
+  const text2 = await readText(path);
+  if (text2 === void 0)
+    return void 0;
+  try {
+    const r = RepoManifest.safeParse((0, import_yaml2.parse)(text2));
+    return r.success ? r.data.repos : null;
+  } catch {
+    return null;
+  }
+}
+var HEADER = "# Proposed by atticus repos discover. Types come from each repo's files; owners marked\n# `unassigned` and missing systems are questions (see QUESTIONS.md). Review before use.\n";
+async function reposDiscover(root, source, o = {}, paths) {
+  const p = paths ?? await resolveMetarepo(root);
+  let platform = o.platform;
+  if (!platform) {
+    try {
+      const profiles = (await readdir2(join3(p.orgPackDir, "profiles"), { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+      platform = profiles.length === 1 ? profiles[0] : "default";
+    } catch {
+      platform = "default";
+    }
+  }
+  const found = [];
+  let skipped = [];
+  const used = /* @__PURE__ */ new Set();
+  const uniqueId = (name) => {
+    let id = slug(name);
+    for (let n = 2; used.has(id); n++)
+      id = `${slug(name)}-${n}`;
+    used.add(id);
+    return id;
+  };
+  if ("dir" in source) {
+    const c = await localCandidates(source.dir);
+    skipped = c.skipped;
+    for (const { dir, repo, modules } of c.repos) {
+      const det = await detectRepoType(repo);
+      const rel = toPosix(relative2(root, dir));
+      const inside = !rel.startsWith("..") && !isAbsolute(rel);
+      const url = o.inPlace && inside ? rel === "" ? "." : `./${rel}` : await originUrl(dir) ?? toPosix(resolve(dir));
+      const entry = {
+        id: uniqueId(dir === source.dir ? basename(resolve(dir)) : basename(dir)),
+        url,
+        defaultBranch: await headBranch(dir) ?? "main",
+        branches: [],
+        type: det.type,
+        owner: UNASSIGNED,
+        extractors: [],
+        dialects: [],
+        sparse: [],
+        archived: false,
+        hosts: [],
+        modules: (modules ?? []).map((m) => ({ path: m, component: slug(m), hosts: [] }))
+      };
+      found.push({ entry, detection: det, dir });
+    }
+  } else {
+    const listed = (await source.host.listRepos(source.org)).sort((a, b) => a.name.localeCompare(b.name));
+    for (const l of listed) {
+      const det = await detectRepoType(await source.host.openRepo(l));
+      found.push({
+        entry: {
+          id: uniqueId(l.name),
+          url: l.url,
+          defaultBranch: l.defaultBranch ?? "main",
+          branches: [],
+          type: det.type,
+          owner: UNASSIGNED,
+          extractors: [],
+          dialects: [],
+          sparse: [],
+          archived: l.archived ?? false,
+          hosts: [],
+          modules: []
+        },
+        detection: det
+      });
+    }
+  }
+  const questions = found.flatMap((f) => questionsFor(f.entry, f.detection));
+  const manifestPath = join3(p.orgPackDir, "profiles", platform, "repos.manifest.yaml");
+  const current = await existingManifest(manifestPath);
+  const result = { platform, repos: found, skipped, questions, wrote: "nothing" };
+  if (o.dryRun)
+    return result;
+  const doc = (repos) => (0, import_yaml2.stringify)({
+    schemaVersion: 1,
+    platform,
+    repos: repos.map((r) => ({
+      id: r.id,
+      url: r.url,
+      defaultBranch: r.defaultBranch,
+      ...r.branches.length ? { branches: r.branches } : {},
+      type: r.type,
+      owner: r.owner,
+      ...r.system ? { system: r.system } : {},
+      ...r.component ? { component: r.component } : {},
+      ...r.archived ? { archived: true } : {},
+      ...r.modules.length ? {
+        modules: r.modules.map((m) => ({
+          path: m.path,
+          component: m.component,
+          ...m.hosts.length ? { hosts: m.hosts } : {}
+        }))
+      } : {}
+    }))
+  }, { lineWidth: 0 });
+  const proposalDir = join3(p.proposalsDir, "repos", platform);
+  if (current === void 0 || current !== null && current.length === 0) {
+    await writeNew(manifestPath, HEADER + doc(found.map((f) => f.entry)), false);
+    result.wrote = "manifest";
+    result.file = toPosix(relative2(root, manifestPath));
+  } else {
+    const kept = current ?? [];
+    const have = new Set(kept.flatMap((r) => [r.id, r.url]));
+    const added = found.filter((f) => !have.has(f.entry.id) && !have.has(f.entry.url));
+    const file = join3(proposalDir, "repos.manifest.yaml");
+    await writeNew(file, HEADER + doc([...kept, ...added.map((a) => a.entry)]), false);
+    result.wrote = "proposal";
+    result.file = toPosix(relative2(root, file));
+  }
+  if (questions.length) {
+    const qf = join3(proposalDir, "QUESTIONS.md");
+    await writeNew(qf, [
+      `# Questions for ${platform}`,
+      "",
+      "Discovery read files only; these need a person.",
+      "",
+      ...questions.map((q) => `- [ ] ${q.repo} (${q.field}): ${q.question}`),
+      ""
+    ].join("\n"), false);
+    result.questionsFile = toPosix(relative2(root, qf));
+  }
+  return result;
+}
+
+// packages/adopt/dist/orgpack-files.js
+var import_yaml3 = __toESM(require_dist(), 1);
+import { join as join4 } from "node:path";
+var yaml = (data, header) => `${header ? `# ${header}
+` : ""}${(0, import_yaml3.stringify)(data, { lineWidth: 0 })}`;
+var DEFAULT_HEADER = "Built-in default written out by Atticus. Change it through a pull request; delete the file to go back to the default.";
+var CHECKLISTS_README = "# Checklists\n\nCritic rule packs (contract C3), one YAML file per pack. The constitution is built in; packs here add organisation rules.\n";
+var STARTER_CHECKLISTS_README = `${CHECKLISTS_README}
+\`review.yaml\` is the starter review (ADR 0120): AI rules the critic's lenses apply to every draft, judging its meaning against the estate and the brief, and two code checks (a call's timeout, a store write's rollback step). It is this organisation's configuration, not the constitution: change, waive or retire its rules, or delete one, through a pull request. Delete the file to turn the starter review off; \`atticus upgrade\` won't add it back.
+`;
+var FOLDER_READMES = [
+  [
+    "patterns/README.md",
+    "# Integration patterns\n\nOne YAML file per approved pattern (`<code>.yaml`). Planned interfaces must name one.\n"
+  ],
+  [
+    "dialects/README.md",
+    "# Dialects\n\nRule files that teach the scan a house framework (contract C2). Start one with `atticus dialect new`.\n"
+  ],
+  [
+    "agents/README.md",
+    "# Agents\n\nAI agent definitions (contract C5), one YAML file per agent.\n"
+  ],
+  [
+    "process/snow/README.md",
+    "# Service-desk templates\n\nOne YAML file per request template. `atticus templates draft` proposes them from wikis and past tickets.\n"
+  ]
+];
+async function writeStartingPack(dir, p) {
+  const files = [
+    [
+      "pack.yaml",
+      yaml({ schemaVersion: 1, name: p.name, version: "0.1.0", owner: p.owner }, "The org pack.")
+    ],
+    ["sources.yaml", yaml(p.sources, "Where things are and what Atticus reads.")],
+    [
+      `profiles/${p.platform}/profile.yaml`,
+      yaml({
+        schemaVersion: 1,
+        platform: p.platform,
+        name: p.platformName ?? p.platform,
+        systems: []
+      })
+    ],
+    [
+      `profiles/${p.platform}/repos.manifest.yaml`,
+      yaml({ schemaVersion: 1, platform: p.platform, repos: [] })
+    ],
+    ["checklists/README.md", p.defaults ? STARTER_CHECKLISTS_README : CHECKLISTS_README],
+    ...FOLDER_READMES
+  ];
+  if (p.defaults)
+    files.push([STARTER_REVIEW_PATH, await starterReviewText()], ["change-types.yaml", yaml(DEFAULT_CHANGE_TYPES, DEFAULT_HEADER)], ["gates.yaml", yaml(DEFAULT_GATES, DEFAULT_HEADER)], ["runtime.yaml", yaml(DEFAULT_RUNTIME, DEFAULT_HEADER)], ["test-strategy.yaml", yaml(DEFAULT_TEST_STRATEGY, DEFAULT_HEADER)]);
+  const written = [];
+  for (const [rel, text2] of files)
+    if (await writeNew(join4(dir, ...rel.split("/")), text2))
+      written.push(rel);
+  return written.sort();
+}
+
+// packages/adopt/dist/init.js
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join5, resolve as resolve2 } from "node:path";
+var ATTICUS_FOLDER_IGNORE = ["/.atticus/*", "!/.atticus/metarepo.yaml"];
+async function insideRepo(dir) {
+  for (let d = resolve2(dir); ; d = dirname2(d)) {
+    if (await exists(join5(d, ".git")))
+      return true;
+    if (dirname2(d) === d)
+      return false;
+  }
+}
+async function makeRepo(dir, git) {
+  try {
+    await git(["init", "-b", "main"], dir);
+  } catch {
+    await git(["init"], dir);
+    await git(["symbolic-ref", "HEAD", "refs/heads/main"], dir);
+  }
+}
+var README = (name, platform) => `# ${name}
+
+The Atticus metarepo for the ${platform} platform.
+
+- \`org-pack/\`: how this organisation works (change types, gates, patterns, checklists, skills). Changed only through pull requests.
+- \`catalog/generated/\`: the catalog Atticus writes on every scan, one YAML record per file. \`catalog/curated/\` holds people's decisions.
+- \`openspec/\`: changes (\`openspec/changes/<id>/\`) and the living specs.
+- \`workspace/\`, \`.index/\`, \`.runs/\`: local state, never committed.
+
+Next: \`atticus repos discover <folder of clones>\` and \`atticus workspace sync\`, then read each repo: \`/atticus-map <repo>\` in your assistant (or \`atticus map <repo>\`), then \`atticus verify <repo> --write\`.
+`;
+async function init(dir, o) {
+  if (!RecordId.safeParse(o.name).success)
+    throw new AdoptError("usage", `"${o.name}" can't be an org pack name; use a lowercase slug such as shop-platform.`);
+  if (!RecordId.safeParse(o.platform).success)
+    throw new AdoptError("usage", `"${o.platform}" can't be a platform id; use a lowercase slug such as shop.`);
+  if (await isDir(join5(dir, ORG_PACK_DIR)))
+    throw new AdoptError("exists", `${join5(dir, ORG_PACK_DIR)} already exists; this folder is already a metarepo.`);
+  if (await isDir(join5(dir, ".atticus", ORG_PACK_DIR)))
+    throw new AdoptError("exists", "This repo is adopted in place (.atticus/org-pack); use it as it is, or run atticus unadopt first.");
+  if (o.packFrom && !await isDir(o.packFrom))
+    throw new AdoptError("usage", `There is no org pack folder at ${o.packFrom}.`);
+  await mkdir2(dir, { recursive: true });
+  let gitState = "inside";
+  let gitNote;
+  if (!await insideRepo(dir)) {
+    try {
+      await makeRepo(dir, o.git ?? createGit());
+      gitState = "initialised";
+    } catch (e) {
+      gitState = "unavailable";
+      gitNote = `git didn't run (${e.message.split("\n")[0]}), so the folder isn't a git repository yet: run git init -b main in it.`;
+    }
+  }
+  const before = new Set(await listFiles(dir));
+  const orgPack = join5(dir, ORG_PACK_DIR);
+  const questions = [];
+  const owner = o.owner ?? "unassigned";
+  if (!o.owner && !o.packFrom)
+    questions.push("Who owns the org pack? Set owner in org-pack/pack.yaml (normally the platform lead).");
+  if (o.packFrom) {
+    await copyDir(o.packFrom, orgPack);
+    await writeStartingPack(orgPack, {
+      name: o.name,
+      platform: o.platform,
+      owner,
+      sources: { schemaVersion: SOURCES_SCHEMA_VERSION },
+      defaults: false
+    });
+  } else {
+    await writeStartingPack(orgPack, {
+      name: o.name,
+      platform: o.platform,
+      owner,
+      sources: { schemaVersion: SOURCES_SCHEMA_VERSION },
+      defaults: true
+    });
+  }
+  let mode = "folders";
+  let note;
+  if ((o.openspec ?? "auto") !== "folders") {
+    try {
+      const os = createOpenSpec({ root: dir });
+      await os.assertSupported();
+      if (!await exists(join5(dir, "openspec", "config.yaml")))
+        await os.init();
+      mode = "cli";
+    } catch (e) {
+      if (o.openspec === "cli")
+        throw e;
+      note = `The OpenSpec CLI didn't run (${e.message.split("\n")[0]}), so openspec/ was made as plain folders.`;
+    }
+  }
+  if (mode === "folders") {
+    await mkdir2(join5(dir, "openspec", "specs"), { recursive: true });
+    await mkdir2(join5(dir, "openspec", "changes", "archive"), { recursive: true });
+    await writeNew(join5(dir, "openspec", "specs", "README.md"), "# Living specs\n");
+    await writeNew(join5(dir, "openspec", "changes", "archive", "README.md"), "# Archived changes\n");
+  }
+  await writeOrgFlowSchema(dir);
+  await setDefaultSchema(dir, ORG_FLOW);
+  let store;
+  if (o.openspecStore) {
+    const id = storeIdOf(o.name);
+    await writeStoreMarker(dir, { id });
+    store = { id };
+  }
+  await writeNew(join5(dir, "catalog", "generated", "README.md"), "# Generated catalog\n\nWritten by `atticus scan`. Don't edit: record decisions in catalog/curated/.\n");
+  await writeNew(join5(dir, "catalog", "curated", "README.md"), "# Curated decisions\n\nPeople's decisions (aliases, names, confirmations) applied over every scan.\n");
+  await writeNew(join5(dir, "README.md"), README(o.name, o.platform));
+  await ensureGitignore(dir);
+  const gi = join5(dir, ".gitignore");
+  const text2 = await readFile2(gi, "utf8");
+  if (!/^\/?\.atticus(\/\*?)?$/m.test(text2))
+    await writeFile2(gi, `${text2.endsWith("\n") ? text2 : `${text2}
+`}${ATTICUS_FOLDER_IGNORE.join("\n")}
+`, "utf8");
+  const op = await loadOrgPack(orgPack);
+  let assistantFiles = 0;
+  try {
+    const a = await generateAssistantFiles(dir);
+    assistantFiles = a.results.filter((x) => x.written).length;
+  } catch {
+  }
+  const created = (await listFiles(dir)).filter((f) => !before.has(f));
+  return {
+    root: dir,
+    created,
+    assistantFiles,
+    openspec: mode,
+    ...store ? { openspecStore: store } : {},
+    ...note ? { openspecNote: note } : {},
+    problems: op.problems,
+    questions,
+    git: gitState,
+    ...gitNote ? { gitNote } : {}
+  };
+}
+
+// packages/adopt/dist/adopt.js
+var import_yaml4 = __toESM(require_dist(), 1);
+import { mkdir as mkdir3, readdir as readdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, join as join6, resolve as resolve3 } from "node:path";
+var SNAPSHOT_FILE = `${ATTICUS_DIR}/state/adopt-snapshot.json`;
+var ADOPTED_FILE = `${ATTICUS_DIR}/adopted.yaml`;
+var PROMPT_DIRS = [".github/prompts", ".claude/commands", "prompts", ".prompts"];
+var AGENT_DIRS = [".github/agents", ".claude/agents", ".github/chatmodes"];
+var SKILL_DIRS = [".claude/skills", ".github/instructions", "skills"];
+var INSTRUCTION_FILES = ["CLAUDE.md", "AGENTS.md", ".github/copilot-instructions.md"];
+var CONSTITUTIONS = [
+  ".specify/memory/constitution.md",
+  "memory/constitution.md",
+  "CONSTITUTION.md",
+  "constitution.md",
+  "docs/constitution.md"
+];
+async function isOpenSpecFolder(dir) {
+  return await exists(join6(dir, "config.yaml")) || await exists(join6(dir, "project.md")) || await isDir(join6(dir, "specs")) || await isDir(join6(dir, "changes"));
+}
+async function detect(root) {
+  const d = { prompts: [], agents: [], skills: [], instructions: [] };
+  if (await isDir(join6(root, "openspec")) && await isOpenSpecFolder(join6(root, "openspec")))
+    d.openspec = "openspec";
+  else {
+    for (const e of (await readdir3(root, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!e.isDirectory() || e.name.startsWith(".") || e.name === "node_modules")
+        continue;
+      const cand = join6(root, e.name, "openspec");
+      if (await isDir(cand) && await isOpenSpecFolder(cand)) {
+        d.openspec = `${e.name}/openspec`;
+        break;
+      }
+    }
+  }
+  if (await isDir(join6(root, ".specify"))) {
+    d.speckit = { specify: ".specify" };
+    if (await isDir(join6(root, "specs")))
+      d.speckit.specs = "specs";
+    if (await exists(join6(root, ".specify/memory/constitution.md")))
+      d.speckit.constitution = ".specify/memory/constitution.md";
+  }
+  for (const c of CONSTITUTIONS)
+    if (await exists(join6(root, c))) {
+      d.constitution = c;
+      break;
+    }
+  for (const p of PROMPT_DIRS)
+    if (await isDir(join6(root, p)))
+      d.prompts.push(p);
+  for (const p of AGENT_DIRS)
+    if (await isDir(join6(root, p)))
+      d.agents.push(p);
+  for (const p of SKILL_DIRS)
+    if (await isDir(join6(root, p)))
+      d.skills.push(p);
+  for (const f of INSTRUCTION_FILES)
+    if (await exists(join6(root, f)))
+      d.instructions.push(f);
+  if (await isDir(join6(root, "catalog", "generated")))
+    d.catalog = "catalog";
+  for (const c of ["CODEOWNERS", ".github/CODEOWNERS", "docs/CODEOWNERS"])
+    if (await exists(join6(root, c))) {
+      d.codeowners = c;
+      break;
+    }
+  return d;
+}
+async function takeSnapshot(root) {
+  const skipNames = /* @__PURE__ */ new Set([".git", "node_modules"]);
+  const files = await hashTree(root, { skipPaths: [ATTICUS_DIR] });
+  const dirs = (await listDirs(root, skipNames)).filter((d) => d !== ATTICUS_DIR && !d.startsWith(`${ATTICUS_DIR}/`));
+  return { schemaVersion: 1, files, dirs };
+}
+var GITIGNORE = `# Atticus local state in an adopted repo: never committed.
+${STATE_FOLDERS.map((f) => `/${f}/`).join("\n")}
+/executors.yaml
+/inputs/inbox/
+`;
+var README2 = `# .atticus
+
+This repo is adopted by Atticus in place. Everything Atticus owns is in this folder; no other
+file of the repo was changed.
+
+- \`org-pack/\`: how Atticus works here. \`org-pack/sources.yaml\` \`layout\` points at the repo's
+  own OpenSpec folder, catalog, constitution, prompts and skills; nothing was moved.
+- \`adopted.yaml\`: what adopt found.
+- \`proposals/\`: what Atticus proposes for people to review (repos, absorbed items).
+- Local state (\`workspace/\`, \`.index/\`, \`.runs/\`, \`state/\`) is ignored by \`.gitignore\` here.
+
+To remove Atticus: \`atticus unadopt\`. It deletes this folder and anything else Atticus created
+since adoption, and leaves every other file exactly as it was.
+`;
+async function adopt(path, o = {}) {
+  const t0 = performance.now();
+  const root = resolve3(path);
+  if (!await isDir(root))
+    throw new AdoptError("not-found", `There is no folder ${path}.`);
+  if (await isDir(join6(root, ATTICUS_DIR, ORG_PACK_DIR)))
+    throw new AdoptError("exists", `${path} is already adopted (${ATTICUS_DIR}/${ORG_PACK_DIR}).`);
+  if (await isDir(join6(root, ORG_PACK_DIR)))
+    throw new AdoptError("exists", `${path} is already an Atticus metarepo (org-pack/); use it with --root as it is.`);
+  const snapshot2 = await takeSnapshot(root);
+  const detected = await detect(root);
+  const folder = slug(basename2(root));
+  const platform = o.platform ?? folder;
+  const name = o.name ?? folder;
+  const layout = {
+    openspec: detected.openspec ?? `${ATTICUS_DIR}/openspec`,
+    catalog: detected.catalog ?? `${ATTICUS_DIR}/catalog`,
+    ...detected.constitution ? { constitution: detected.constitution } : {},
+    skills: detected.skills,
+    prompts: detected.prompts
+  };
+  const paths = pathsFor(root, true, layout);
+  const a = join6(root, ATTICUS_DIR);
+  await mkdir3(a, { recursive: true });
+  await writeStartingPack(paths.orgPackDir, {
+    name,
+    platform,
+    owner: "unassigned",
+    sources: { schemaVersion: SOURCES_SCHEMA_VERSION, layout },
+    defaults: true
+  });
+  if (!detected.openspec) {
+    await writeNew(join6(a, "openspec", "specs", "README.md"), "# Living specs\n");
+    await writeNew(join6(a, "openspec", "changes", "archive", "README.md"), "# Archived changes\n");
+    await writeOrgFlowSchema(a);
+    await setDefaultSchema(a, ORG_FLOW);
+  }
+  if (!detected.catalog) {
+    await writeNew(join6(a, "catalog", "generated", "README.md"), "# Generated catalog\n\nWritten by `atticus scan`.\n");
+    await writeNew(join6(a, "catalog", "curated", "README.md"), "# Curated decisions\n\nPeople's decisions applied over every scan.\n");
+  }
+  await writeNew(join6(a, ".gitignore"), GITIGNORE);
+  await writeNew(join6(a, "README.md"), README2);
+  const disc = await reposDiscover(root, { dir: root }, { platform, inPlace: true }, paths);
+  await writeNew(join6(root, ADOPTED_FILE), (0, import_yaml4.stringify)({
+    schemaVersion: 1,
+    platform,
+    detected,
+    repos: disc.repos.map((r) => ({
+      id: r.entry.id,
+      path: r.entry.url,
+      type: r.detection.type,
+      signals: r.detection.signals
+    }))
+  }, { lineWidth: 0 }));
+  await mkdir3(join6(root, ATTICUS_DIR, "state"), { recursive: true });
+  await writeFile3(join6(root, SNAPSHOT_FILE), JSON.stringify(snapshot2, null, 1), "utf8");
+  const after = await hashTree(root, { skipPaths: [ATTICUS_DIR] });
+  const changed = Object.keys({ ...snapshot2.files, ...after }).filter((f) => snapshot2.files[f] !== after[f]);
+  if (changed.length)
+    throw new AdoptError("source", `Adopt changed files outside ${ATTICUS_DIR}/, which it must never do: ${changed.join(", ")}. Run atticus unadopt.`);
+  const op = await loadOrgPack(paths.orgPackDir);
+  const written = (await listFiles(a)).map((f) => toPosix(`${ATTICUS_DIR}/${f}`));
+  return {
+    root,
+    platform,
+    detected,
+    layout,
+    repos: disc.repos,
+    questions: disc.questions,
+    written,
+    problems: op.problems,
+    ms: Math.round(performance.now() - t0)
+  };
+}
+
+// packages/adopt/dist/unadopt.js
+import { readFile as readFile3, rm, rmdir, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join7, resolve as resolve4 } from "node:path";
+var ROOT_STATE = ["workspace", ".index", ".runs"];
+var CHANGE_OWNED = /* @__PURE__ */ new Set(["change.yaml", "brief.md", "repos.yaml", "ux.md"]);
+function changeOwned(path, openspec, sure, newChange) {
+  const prefix = `${openspec}/changes/`;
+  if (!path.startsWith(prefix))
+    return false;
+  const parts = path.slice(prefix.length).split("/");
+  const lead = parts[0] === "archive" ? 2 : 1;
+  if (parts.length <= lead)
+    return false;
+  const inChange = parts.slice(lead);
+  if (inChange[0] === "review")
+    return true;
+  if (inChange.length !== 1)
+    return false;
+  if (inChange[0] === "change.yaml")
+    return true;
+  if (!sure)
+    return false;
+  if (CHANGE_OWNED.has(inChange[0]))
+    return true;
+  const changeYaml = `${prefix}${parts.slice(0, lead).join("/")}/change.yaml`;
+  return inChange[0] === ".openspec.yaml" && newChange(changeYaml);
+}
+function withoutSection(text2) {
+  const s = findSection(text2);
+  if (!s)
+    return [];
+  const lines = text2.split("\n");
+  const before = lines.slice(0, s.start).join("\n");
+  const after = lines.slice(s.end + 1).join("\n");
+  const out = /* @__PURE__ */ new Set();
+  if (after === "" || after === "\n") {
+    for (const b of [before, `${before}
+`, before.replace(/\n$/, ""), before.replace(/\n\n$/, "")])
+      out.add(b);
+    if (before === "")
+      out.add("");
+  } else
+    out.add([...lines.slice(0, s.start), ...lines.slice(s.end + 1)].join("\n"));
+  return [...out];
+}
+async function unadopt(path) {
+  const root = resolve4(path);
+  const a = join7(root, ATTICUS_DIR);
+  if (!await isDir(a))
+    throw new AdoptError("not-adopted", `${path} isn't adopted: there is no ${ATTICUS_DIR}/ folder.`);
+  const layout = await readLayout(join7(a, "org-pack"));
+  let snap;
+  try {
+    snap = JSON.parse(await readFile3(join7(root, SNAPSHOT_FILE), "utf8"));
+  } catch {
+    snap = void 0;
+  }
+  const res = {
+    removed: [],
+    restored: [],
+    keptNew: [],
+    changed: [],
+    missing: [],
+    hadSnapshot: !!snap
+  };
+  const before = snap?.files ?? {};
+  const existed = (p) => p in before;
+  await rm(a, { recursive: true, force: true });
+  res.removed.push(`${ATTICUS_DIR}/`);
+  for (const f of ROOT_STATE) {
+    const had = snap ? Object.keys(before).some((p) => p === f || p.startsWith(`${f}/`)) || snap.dirs.includes(f) : true;
+    if (!had && await isDir(join7(root, f))) {
+      await rm(join7(root, f), { recursive: true, force: true });
+      res.removed.push(`${f}/`);
+    }
+  }
+  const openspecs = [
+    ...layout.openspec.startsWith(`${ATTICUS_DIR}/`) ? [] : [layout.openspec],
+    ...snap && layout.openspec !== "openspec" && !snap.dirs.includes("openspec") ? ["openspec"] : []
+  ];
+  const strayCatalog = !!snap && layout.catalog !== "catalog" && !snap.dirs.includes("catalog") && await isDir(join7(root, "catalog"));
+  if (strayCatalog) {
+    await rm(join7(root, "catalog"), { recursive: true, force: true });
+    res.removed.push("catalog/");
+  }
+  const files = await listFiles(root);
+  const present = new Set(files);
+  const newChange = (changeYaml) => present.has(changeYaml) && !existed(changeYaml);
+  for (const f of files) {
+    const full = join7(root, f);
+    if (existed(f)) {
+      const now = sha256(await readFile3(full));
+      if (now === before[f])
+        continue;
+      const text2 = await readText(full) ?? "";
+      const back = withoutSection(text2).find((t) => sha256(t) === before[f]);
+      if (back !== void 0) {
+        await writeFile4(full, back, "utf8");
+        res.restored.push(f);
+      } else
+        res.changed.push(f);
+      continue;
+    }
+    let atticus = openspecs.some((o) => changeOwned(f, o, !!snap, newChange));
+    if (!atticus) {
+      const text2 = await readText(full);
+      if (text2 !== void 0 && parseHeader(text2))
+        atticus = true;
+      else if (text2 !== void 0 && findSection(text2)) {
+        const back = withoutSection(text2)[0];
+        if (back === void 0 || back.trim() === "")
+          atticus = true;
+        else {
+          await writeFile4(full, back, "utf8");
+          res.restored.push(f);
+          continue;
+        }
+      }
+    }
+    if (atticus) {
+      await rm(full, { force: true });
+      res.removed.push(f);
+    } else if (snap)
+      res.keptNew.push(f);
+  }
+  if (snap) {
+    for (const f of Object.keys(before))
+      if (!await exists(join7(root, f)))
+        res.missing.push(f);
+  }
+  if (snap) {
+    const had = new Set(snap.dirs);
+    for (const d of (await listDirs(root)).reverse()) {
+      if (had.has(d))
+        continue;
+      try {
+        await rmdir(join7(root, d));
+      } catch {
+      }
+    }
+  }
+  res.removed.sort();
+  return res;
+}
+
+// packages/adopt/dist/absorb/types.js
+var NOT_TRANSLATABLE = /* @__PURE__ */ new Set(["doc", "code"]);
+
+// packages/adopt/dist/absorb/critic.js
+var import_yaml5 = __toESM(require_dist(), 1);
+var known = new Set(BUILT_IN_CHECKS.map((c) => c.id));
+var ALL_MAPPINGS = [
+  {
+    re: /pattern code.*registry|registry.*pattern code|pattern.*in the (pattern )?registry/i,
+    check: "pattern-code-in-registry",
+    lens: "architecture",
+    artifacts: ["interfaces"]
+  },
+  {
+    re: /approved (integration )?pattern/i,
+    check: "interface-pattern-approved",
+    lens: "architecture",
+    artifacts: ["interfaces"]
+  },
+  {
+    re: /(names?|has|uses) an? (integration )?pattern/i,
+    check: "interface-has-pattern",
+    lens: "architecture",
+    artifacts: ["interfaces"]
+  },
+  {
+    re: /both ends|(caller|callee)s?.*(catalog|known)|ends? of (every|each) interface/i,
+    check: "interface-ends-in-catalog",
+    lens: "architecture",
+    artifacts: ["interfaces"]
+  },
+  {
+    re: /vendor.*operation|operation.*vendor/i,
+    check: "vendor-operation-known",
+    lens: "architecture",
+    artifacts: ["interfaces"]
+  },
+  {
+    re: /timeouts?|retr(y|ies)|circuit.?breaker/i,
+    check: "settings-present",
+    lens: "architecture",
+    artifacts: ["interfaces", "design"],
+    params: (t) => ({
+      settingKinds: [
+        .../timeout/i.test(t) ? ["timeout"] : [],
+        .../retr(y|ies)/i.test(t) ? ["retry"] : [],
+        .../circuit.?breaker/i.test(t) ? ["circuit-breaker"] : []
+      ]
+    })
+  },
+  {
+    re: /alerts?|dashboards?|observability/i,
+    check: "observability-present",
+    lens: "release",
+    artifacts: ["design"],
+    params: (t) => ({
+      assetKinds: [
+        .../alert/i.test(t) ? ["alert"] : [],
+        .../dashboard/i.test(t) ? ["dashboard"] : []
+      ].concat(/alert|dashboard/i.test(t) ? [] : ["alert"])
+    })
+  },
+  {
+    re: /acceptance criteria/i,
+    check: "story-has-acceptance-criteria",
+    lens: "story",
+    artifacts: ["stories"]
+  },
+  {
+    re: /requirement.*scenario|scenario.*requirement/i,
+    check: "spec-scenarios-present",
+    lens: "story",
+    artifacts: ["specs"]
+  },
+  {
+    re: /(story|stories).*(covered by|has|have).*task|task.*(every|each) story/i,
+    check: "tasks-cover-stories",
+    lens: "delivery",
+    artifacts: ["tasks"]
+  },
+  {
+    re: /mappings?/i,
+    check: "mappings-cover-interfaces",
+    lens: "architecture",
+    artifacts: ["mappings"]
+  },
+  {
+    re: /how long.*(kept|retained)|retention/i,
+    check: "data-retention-stated",
+    lens: "architecture",
+    artifacts: ["data"]
+  },
+  {
+    re: /personal data|classif/i,
+    check: "data-columns-classified",
+    lens: "architecture",
+    artifacts: ["data"]
+  },
+  {
+    re: /migration/i,
+    check: "data-migration-named",
+    lens: "architecture",
+    artifacts: ["data"]
+  },
+  {
+    re: /data (design|doc)|data\.md|touches a data store/i,
+    check: "data-doc-present",
+    lens: "architecture",
+    artifacts: ["data"]
+  },
+  {
+    re: /service.?desk|change request|snow/i,
+    check: "snow-drafts-present",
+    lens: "delivery",
+    artifacts: ["snow"]
+  },
+  {
+    re: /instructions? (aimed at|for|to) an? (assistant|ai|agent|model)|prompt injection/i,
+    check: "no-embedded-instructions",
+    lens: "architecture",
+    artifacts: ["brief", "proposal", "design", "stories"]
+  }
+];
+var MAPPINGS = ALL_MAPPINGS.filter((m) => known.has(m.check));
+function lensOf(t) {
+  if (/\b(tests?|coverage|lint|dependency|library|libraries|code)\b/i.test(t))
+    return "code-and-test";
+  if (/\b(story|stories|sprint|acceptance|persona|user journey)\b/i.test(t))
+    return "story";
+  if (/\b(screen|ux|accessib\w*|wcag|usability|copy)\b/i.test(t))
+    return "ux";
+  if (/\b(roll(ed|s|ing)? ?back|release|deploy\w*|go-?live|runbook|on-?call)\b/i.test(t))
+    return "release";
+  if (/\b(business|value|kpi|cost|benefit|customer)\b/i.test(t))
+    return "business";
+  if (/\b(estimate|plan|milestone|owner|team)\b/i.test(t))
+    return "delivery";
+  return "architecture";
+}
+var ARTIFACTS_BY_LENS = {
+  business: ["brief", "proposal"],
+  architecture: ["design", "interfaces"],
+  story: ["stories"],
+  ux: ["ux"],
+  delivery: ["tasks"],
+  "code-and-test": ["code", "tests"],
+  release: ["design", "release"]
+};
+function severityOf(item, deterministic) {
+  const s = item.severity?.toLowerCase();
+  if (s) {
+    if (/block|critical|high|must|error/.test(s))
+      return "blocking";
+    if (/medium|warn|major|risk/.test(s))
+      return "risk";
+    if (/low|minor|info|idea|nice/.test(s))
+      return "idea";
+  }
+  if (/\b(never|must|no (credentials|secrets|tokens))\b/i.test(item.text))
+    return "blocking";
+  return deterministic ? "blocking" : "risk";
+}
+function needsOf(t) {
+  if (/timeouts?|retr(y|ies)/i.test(t))
+    return [
+      {
+        kind: "Setting",
+        scope: "touched-components",
+        question: "What timeouts and retries does ${record} use?"
+      }
+    ];
+  if (/alerts?|dashboards?/i.test(t))
+    return [
+      {
+        kind: "ObservabilityAsset",
+        scope: "touched-components",
+        question: "Which alerts and dashboards cover ${record}?"
+      }
+    ];
+  if (/retention|how long/i.test(t))
+    return [
+      {
+        kind: "Table",
+        field: "retention",
+        scope: "touched-data-stores",
+        question: "How long are the rows of ${record} kept?"
+      }
+    ];
+  return [];
+}
+var clean = (t) => t.replace(/^\s*(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?/, "").replace(/\s+/g, " ").trim();
+function translateCriticItem(item, o) {
+  const text2 = clean(item.text);
+  const map = MAPPINGS.find((m) => m.re.test(text2));
+  const deterministic = !!map;
+  const severity = o.layer === "constitution" && !item.severity ? "blocking" : severityOf(item, deterministic);
+  const lens = map?.lens ?? lensOf(`${item.section ?? ""} ${text2}`);
+  const base = slug(`${o.prefix}-${item.sourceId ?? text2.split(/\s+/).slice(0, 7).join(" ")}`).slice(0, 90);
+  let id = base;
+  for (let n = 2; o.usedIds.has(id); n++)
+    id = `${base}-${n}`;
+  o.usedIds.add(id);
+  const title = text2.length > 120 ? `${text2.slice(0, 117)}...` : text2;
+  const rule = {
+    id,
+    title,
+    ...text2.length > 120 ? { description: text2 } : {},
+    layer: o.layer,
+    lens,
+    appliesTo: { artifacts: map?.artifacts ?? ARTIFACTS_BY_LENS[lens] },
+    severity,
+    check: map ? { type: "deterministic", check: map.check, params: map.params?.(text2) ?? {} } : {
+      type: "ai",
+      prompt: `Check that this holds for the change: ${text2} Quote the artifact line that shows it; when nothing shows it, report a finding with the fix.`
+    },
+    waivable: o.layer !== "constitution" && severity === "blocking",
+    source: `${o.source}:${item.line}`,
+    status: "draft",
+    needs: needsOf(text2)
+  };
+  const r = ChecklistRule.safeParse(rule);
+  return {
+    rule,
+    deterministic,
+    confidence: map ? "high" : item.severity ? "medium" : "low",
+    problems: r.success ? [] : r.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+function markdownItems(text2) {
+  const out = [];
+  let section;
+  text2.split("\n").forEach((l, i) => {
+    const h = /^#{1,6}\s+(.*)$/.exec(l);
+    if (h) {
+      section = h[1].trim();
+      return;
+    }
+    if (/^\s{0,3}(?:[-*+]|\d+[.)])\s+\S/.test(l) && clean(l).length >= 12)
+      out.push({ text: l, line: i + 1, ...section ? { section } : {} });
+  });
+  return out;
+}
+function yamlItems(text2) {
+  let data;
+  try {
+    data = (0, import_yaml5.parse)(text2);
+  } catch {
+    return void 0;
+  }
+  const obj = data && typeof data === "object" ? data : {};
+  const list = ["items", "rules", "checks", "checklist"].map((k) => obj[k]).find(Array.isArray);
+  if (!list?.length)
+    return void 0;
+  const lines = text2.split("\n");
+  const out = [];
+  for (const raw of list) {
+    const e = typeof raw === "string" ? { text: raw } : raw ?? {};
+    const t = [e.text, e.title, e.rule, e.check, e.description].find((v) => typeof v === "string" && v.trim());
+    if (!t)
+      continue;
+    const at = lines.findIndex((l) => l.includes(t.slice(0, 40)));
+    out.push({
+      text: t,
+      line: at >= 0 ? at + 1 : 1,
+      ...typeof e.id === "string" ? { sourceId: e.id } : {},
+      ...typeof e.severity === "string" ? { severity: e.severity } : {}
+    });
+  }
+  return out.length ? out : void 0;
+}
+function packFor(name, description, rules) {
+  const pack = { schemaVersion: 1, name, version: "0.1.0", description, rules };
+  const r = ChecklistPack.safeParse(pack);
+  return {
+    content: `# Drafted by atticus absorb. Every rule is a draft: review, then set status: active.
+${(0, import_yaml5.stringify)(pack, { lineWidth: 0 })}`,
+    problems: r.success ? [] : r.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+
+// packages/adopt/dist/absorb/speckit.js
+function parseConstitution(text2) {
+  const lines = text2.split("\n");
+  const out = {
+    principles: [],
+    sections: [],
+    generatedByAtticus: /Generated from the Atticus constitution/.test(text2)
+  };
+  let h2;
+  let current;
+  const flush = () => {
+    if (!current)
+      return;
+    const body = current.body.join("\n").trim();
+    if (current.principle)
+      out.principles.push({
+        title: current.title.replace(/^[IVXLCDM]+\.\s*/, "").replace(/\s*\(NON-NEGOTIABLE\)\s*$/i, ""),
+        body,
+        line: current.line,
+        nonNegotiable: /NON-NEGOTIABLE/i.test(current.title)
+      });
+    else if (body)
+      out.sections.push({ title: current.title, body, line: current.line });
+    current = void 0;
+  };
+  lines.forEach((l, i) => {
+    const m2 = /^##\s+(.+)$/.exec(l);
+    const m3 = /^###\s+(.+)$/.exec(l);
+    if (m2) {
+      flush();
+      h2 = m2[1].trim();
+      if (!/principles/i.test(h2))
+        current = { title: h2, body: [], line: i + 1, principle: false };
+      return;
+    }
+    if (m3 && h2 && /principles/i.test(h2)) {
+      flush();
+      current = { title: m3[1].trim(), body: [], line: i + 1, principle: true };
+      return;
+    }
+    if (/^\*\*Version\*\*/.test(l))
+      return;
+    current?.body.push(l);
+  });
+  flush();
+  return out;
+}
+function changeTemplateFrom(id, name, text2) {
+  const body = [];
+  for (const raw of text2.split("\n")) {
+    const l = raw.replace(/\[FEATURE NAME\]|\[FEATURE\]/g, "{{title}}").replace(/\[DATE\]/g, "{{date}}").replace(/\[###-feature-name\]/g, "{{id}}");
+    if (/^#\s/.test(l))
+      body.push("# {{title}}", "");
+    else if (/^#{2,6}\s/.test(l))
+      body.push(l.replace(/\s*\*\([^)]*\)\*\s*$/, ""), "");
+    else if (l.trim() && !/^\*\*(Feature Branch|Created|Status)\*\*/.test(l))
+      body.push(`<!-- ${l.trim().replace(/-->/g, "")} -->`, "");
+  }
+  const skeleton = body.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  return `---
+id: ${id}
+name: ${name}
+changeType: feature
+description: Drafted by atticus absorb from a Spec Kit spec template.
+---
+${skeleton}
+`;
+}
+function openSpecFrom(feature, text2) {
+  const title = /^#\s+Feature Specification:\s*(.+)$/m.exec(text2)?.[1]?.trim() ?? feature;
+  const reqs = [...text2.matchAll(/^\s*-\s+\*\*(FR-\d+)\*\*:\s*(.+)$/gm)].map((m) => ({
+    id: m[1],
+    text: m[2].trim().replace(/\bMUST\b/, "SHALL")
+  }));
+  const scenarios = [
+    ...text2.matchAll(/\*\*Given\*\*\s*(.+?),\s*\*\*When\*\*\s*(.+?),\s*\*\*Then\*\*\s*(.+)$/gm)
+  ].map((m, i) => ({ n: i + 1, given: m[1], when: m[2], then: m[3].trim() }));
+  const out = [
+    `# ${feature} Specification`,
+    "",
+    "## Purpose",
+    "",
+    title,
+    "",
+    "## Requirements",
+    ""
+  ];
+  reqs.forEach((r, i) => {
+    out.push(`### Requirement: ${r.id}`, "", r.text, "");
+    const mine = i === 0 ? scenarios : [];
+    for (const s of mine)
+      out.push(`#### Scenario: Acceptance scenario ${s.n}`, "", `- **GIVEN** ${s.given}`, `- **WHEN** ${s.when}`, `- **THEN** ${s.then}`, "");
+    if (!mine.length)
+      out.push(`#### Scenario: ${r.id} holds`, "", `- **WHEN** the feature is used`, `- **THEN** ${r.text.replace(/^System SHALL\s*/i, "the system does this: ")}`, "");
+  });
+  return { spec: `${out.join("\n").trimEnd()}
+`, requirements: reqs.length };
+}
+
+// packages/adopt/dist/absorb/translate.js
+var import_yaml6 = __toESM(require_dist(), 1);
+function meta(text2) {
+  const fm = frontMatter(text2);
+  let data = {};
+  if (fm.data !== void 0)
+    try {
+      const v = (0, import_yaml6.parse)(fm.data);
+      if (v && typeof v === "object")
+        data = v;
+    } catch {
+    }
+  return { data, body: fm.body };
+}
+var str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+function firstLine(body) {
+  for (const l of body.split("\n")) {
+    const t = l.replace(/^#+\s*/, "").replace(/^\d+[.)]\s*/, "").trim();
+    if (t)
+      return t.length > 160 ? `${t.slice(0, 157)}...` : t;
+  }
+  return void 0;
+}
+var normaliseArgs = (body) => body.replace(/\$\{input:[^}]+\}/g, "$ARGUMENTS").replace(/\{\{ARGS\}\}/g, "$ARGUMENTS");
+function bodyKey(text2) {
+  return normaliseArgs(meta(text2).body).replace(/\$ARGUMENTS/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function promptToCommand(file, text2, prefix) {
+  const { data, body } = meta(text2);
+  const base = file.split("/").pop().replace(/\.prompt\.md$|\.md$/i, "");
+  const id = slug(`${prefix}-${base}`);
+  const heading = firstLine(body);
+  const description = str(data.description) ?? heading?.replace(/\s*prompt$/i, "") ?? `Prompt ${base} from ${prefix}.`;
+  const hint = str(data["argument-hint"]) ?? str(data.argumentHint);
+  const fm = { id, description };
+  if (hint)
+    fm.argumentHint = hint;
+  return {
+    id,
+    title: description,
+    path: `org-pack/process/commands/${id}.md`,
+    content: `---
+${(0, import_yaml6.stringify)(fm, { lineWidth: 0 }).trimEnd()}
+---
+
+${normaliseArgs(body).trim()}
+`,
+    confidence: str(data.description) ? "high" : "medium"
+  };
+}
+function toSkill(file, text2, o) {
+  const { data, body } = meta(text2);
+  const base = file.split("/").filter((s) => s !== "SKILL.md").pop().replace(/\.(agent|chatmode|instructions)\.md$|\.md$/i, "");
+  const id = slug(`${o.prefix}-${o.kind === "instructions" ? `${base}-conventions` : base}`);
+  const description = str(data.description) ?? (o.kind === "instructions" ? `Conventions ${o.prefix} gives its assistants (${file}).` : firstLine(body) ?? `Skill ${base} from ${o.prefix}.`);
+  const name = str(data.name) ?? base.replace(/[-_.]+/g, " ");
+  const m = {
+    id,
+    name,
+    description,
+    owner: o.owner,
+    source: o.source,
+    status: "draft"
+  };
+  const r = SkillMeta.safeParse(m);
+  return {
+    id,
+    title: description,
+    path: `org-pack/process/skills/${id}/SKILL.md`,
+    content: `---
+${(0, import_yaml6.stringify)(m, { lineWidth: 0 }).trimEnd()}
+---
+
+${body.trim()}
+`,
+    confidence: str(data.description) ? "high" : "medium",
+    problems: r.success ? [] : r.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+function schemaKind(file, text2) {
+  if (!/\.(ya?ml|json)$/i.test(file))
+    return void 0;
+  let data;
+  try {
+    data = /\.json$/i.test(file) ? JSON.parse(text2) : (0, import_yaml6.parse)(text2);
+  } catch {
+    return void 0;
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data))
+    return void 0;
+  const d = data;
+  if (typeof d.openapi === "string" || typeof d.swagger === "string")
+    return "openapi";
+  if (typeof d.asyncapi === "string")
+    return "asyncapi";
+  if (typeof d.$schema === "string" || /\.schema\.json$/i.test(file))
+    return "json-schema";
+  return void 0;
+}
+function schemaReference(file, text2, kind, prefix) {
+  const data = /\.json$/i.test(file) ? JSON.parse(text2) : (0, import_yaml6.parse)(text2);
+  const info = data.info ?? {};
+  const title = str(info.title) ?? str(data.title) ?? file;
+  const version = str(info.version) ?? str(data.version);
+  const operations = [];
+  const paths = data.paths ?? data.channels ?? {};
+  for (const [p, ops] of Object.entries(paths))
+    for (const m of Object.keys(ops ?? {}))
+      if (/^(get|put|post|delete|patch|head|options|publish|subscribe|send|receive)$/i.test(m))
+        operations.push(`${m.toUpperCase()} ${p}`);
+  const fields = Object.keys(data.properties ?? {});
+  const id = slug(`${prefix}-${file.replace(/\.(ya?ml|json)$/i, "")}`);
+  const ref = {
+    kind,
+    title,
+    ...version ? { version } : {},
+    source: `${prefix}:${file}`,
+    ...operations.length ? { operations } : {},
+    ...fields.length ? { fields } : {},
+    use: kind === "json-schema" ? "Referenced from interfaces and mappings; intake reads it when copied into inputs/." : "A partner or team API: intake reads it into planned or vendor endpoints when copied into inputs/specs/."
+  };
+  return {
+    id,
+    title,
+    path: `references/schemas/${id}.yaml`,
+    content: (0, import_yaml6.stringify)(ref, { lineWidth: 0 }),
+    confidence: "high"
+  };
+}
+function reference(kind, file, prefix, note) {
+  const id = slug(`${prefix}-${file.replace(/\.[a-z]+$/i, "")}`);
+  return {
+    id,
+    title: file,
+    path: `references/${kind}/${id}.yaml`,
+    content: (0, import_yaml6.stringify)({ kind, source: `${prefix}:${file}`, note }, { lineWidth: 0 }),
+    confidence: "high"
+  };
+}
+var VERBS = /@(get|put|post|patch|delete|head)\b/;
+var ROUTE = /@route\(\s*"([^"]*)"\s*\)/;
+function typespecOutline(text2) {
+  const lines = text2.replace(/\/\/.*$/gm, "").split("\n");
+  const out = { operations: [], models: [] };
+  let pendingRoute;
+  let prefix;
+  let depth = 0;
+  let interfaceDepth;
+  for (const raw of lines) {
+    const l = raw.trim();
+    const ns = /^namespace\s+([\w.]+)/.exec(l);
+    if (ns && !out.namespace)
+      out.namespace = ns[1];
+    const route = ROUTE.exec(l)?.[1];
+    const model = /\bmodel\s+(\w+)/.exec(l);
+    if (model)
+      out.models.push(model[1]);
+    const iface = /\binterface\s+\w+/.test(l);
+    if (iface) {
+      prefix = pendingRoute ?? route ?? "";
+      interfaceDepth = depth;
+      pendingRoute = void 0;
+    }
+    const op = /^((?:@\w+(?:\([^)]*\))?\s+)*)(?:op\s+)?(\w+)\s*\((.*)$/.exec(l);
+    const inInterface = interfaceDepth !== void 0 && depth === interfaceDepth + 1;
+    if (op && !model && !iface && (inInterface || /^(?:@\w+(?:\([^)]*\))?\s+)*op\s/.test(l))) {
+      const decorators = op[1] ?? "";
+      const own = ROUTE.exec(decorators)?.[1] ?? (inInterface ? void 0 : pendingRoute);
+      const verb = VERBS.exec(decorators)?.[1] ?? (/@body\b/.test(op[3] ?? "") ? "post" : "get");
+      const params = [...(op[3] ?? "").matchAll(/@path\s+(\w+)/g)].map((m) => `/{${m[1]}}`);
+      const path = `${inInterface ? prefix ?? "" : ""}${own ?? ""}${params.join("")}` || "/";
+      out.operations.push(`${verb.toUpperCase()} ${path.replace(/\/{2,}/g, "/")}`);
+      pendingRoute = void 0;
+    } else if (route && !iface)
+      pendingRoute = route;
+    for (const c of l) {
+      if (c === "{")
+        depth++;
+      else if (c === "}") {
+        depth--;
+        if (interfaceDepth !== void 0 && depth === interfaceDepth) {
+          interfaceDepth = void 0;
+          prefix = void 0;
+        }
+      }
+    }
+  }
+  out.operations.sort();
+  return out;
+}
+function typespecReference(file, text2, prefix, compiled) {
+  const o = typespecOutline(text2);
+  const id = slug(`${prefix}-${file.replace(/\.tsp$/i, "")}`);
+  const note = compiled.length ? `TypeSpec source. Intake reads its compiled OpenAPI, absorbed as a schema: ${compiled.join(", ")}.` : "TypeSpec source. Intake reads OpenAPI, not TypeSpec: run tsp compile . in its repo (emitter @typespec/openapi3) and absorb again, or put the OpenAPI it writes in inputs/specs/.";
+  return {
+    id,
+    title: o.namespace ? `${o.namespace} (${file})` : file,
+    path: `references/typespec/${id}.yaml`,
+    content: (0, import_yaml6.stringify)({
+      kind: "typespec",
+      source: `${prefix}:${file}`,
+      ...o.namespace ? { namespace: o.namespace } : {},
+      ...o.operations.length ? { operations: o.operations } : {},
+      ...o.models.length ? { models: o.models } : {},
+      note
+    }, { lineWidth: 0 }),
+    confidence: "high"
+  };
+}
+
+// packages/adopt/dist/absorb/source.js
+import { mkdir as mkdir4, rm as rm2 } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join8, resolve as resolve5 } from "node:path";
+import { fileURLToPath } from "node:url";
+var REMOTE = /^[a-z][a-z0-9+.-]*:\/\//i;
+var SCP = /^[^/\\]+@[^:/\\]+:/;
+async function isBare(dir) {
+  return await isDir(join8(dir, "objects")) && await exists(join8(dir, "HEAD")) && !await isDir(join8(dir, ".git"));
+}
+async function openSource(source, o) {
+  let local;
+  if (source.startsWith("file://"))
+    local = fileURLToPath(source);
+  else if (!REMOTE.test(source) && !SCP.test(source))
+    local = isAbsolute2(source) ? source : resolve5(o.root, source);
+  if (local) {
+    if (!await isDir(local))
+      throw new AdoptError("source", `There is no folder or repository at ${source}.`);
+    if (!await isBare(local) && !o.ref)
+      return { dir: local, kind: "folder", url: source };
+  }
+  const target = join8(o.stateDir, "absorbed", o.id);
+  await rm2(target, { recursive: true, force: true });
+  const git = o.git ?? createGit();
+  const url = local && !source.startsWith("file://") ? local : source;
+  await mkdir4(dirname3(target), { recursive: true });
+  try {
+    await git(["clone", "--depth", "1", ...o.ref ? ["--branch", o.ref] : [], "--", url, target], dirname3(target));
+  } catch (e) {
+    throw new AdoptError("source", `Couldn't clone ${source}: ${e.message}`);
+  }
+  return { dir: target, kind: "clone", url: source };
+}
+
+// packages/adopt/dist/absorb/absorb.js
+var import_yaml7 = __toESM(require_dist(), 1);
+import { mkdir as mkdir5, readFile as readFile4, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname4, join as join9 } from "node:path";
+var DOC = /(^|\/)(README|LICENSE|LICENCE|CHANGELOG|CONTRIBUTING|CODE_OF_CONDUCT|SECURITY|NOTICE|CODEOWNERS)(\.(md|txt|rst|adoc))?$/i;
+var CODE = /\.(java|kt|scala|groovy|ts|tsx|js|jsx|mjs|cjs|vue|py|go|cs|fs|rb|php|rs|c|h|cpp|swift|sql|sh|ps1|bat|cbl|cob|jcl|cpy|tf|hcl|gradle|xml|properties|toml|lock|csproj|sln|dockerfile|ini|cfg)$|(^|\/)(Dockerfile|Makefile|tspconfig\.ya?ml|go\.mod|go\.sum|package\.json|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|requirements\.txt|\.gitignore|\.gitattributes|\.editorconfig|\.npmrc|\.nvmrc)$/i;
+var CRITIC_PATH = /(^|\/)(reviews?|critic|critics|checklists?|checks)(\/|$)|checklist|critic/i;
+var PROMPT_DIR = /(^|\/)\.?prompts\//i;
+async function formatOf(dir) {
+  if (await isDir(join9(dir, "org-pack")))
+    return { format: "atticus", orgPack: "org-pack" };
+  if (await isDir(join9(dir, ".atticus", "org-pack")))
+    return { format: "atticus", orgPack: ".atticus/org-pack" };
+  if (await isDir(join9(dir, "openspec")))
+    return { format: "openspec", openspec: "openspec" };
+  if (await isDir(join9(dir, ".specify")))
+    return { format: "speckit" };
+  return { format: "plain" };
+}
+async function absorb(root, source, o, paths) {
+  const t0 = performance.now();
+  if (!RecordId.safeParse(o.id).success)
+    throw new AdoptError("usage", `"${o.id}" can't be an absorbed id; use a lowercase slug such as payments-team.`);
+  const p = paths ?? await resolveMetarepo(root);
+  const opened = await openSource(source, {
+    root,
+    stateDir: p.stateDir,
+    id: o.id,
+    ...o.ref ? { ref: o.ref } : {},
+    ...o.git ? { git: o.git } : {}
+  });
+  const dir = opened.dir;
+  const fmt = await formatOf(dir);
+  if (fmt.format === "atticus" && fmt.orgPack) {
+    const theirs = await loadOrgPack(join9(dir, ...fmt.orgPack.split("/")));
+    fmt.openspec = theirs.sources.layout.openspec;
+  }
+  const files = (await listFiles(dir, { skipNames: /* @__PURE__ */ new Set([".git", "node_modules"]) })).filter((f) => !isLocalState(f, fmt.format === "atticus"));
+  const read = async (f) => (await readFile4(join9(dir, f), "utf8")).replace(/\r\n/g, "\n");
+  const items = [];
+  const problems = [];
+  const claimed = /* @__PURE__ */ new Set();
+  const prefix = o.id;
+  const owner = o.owner ?? o.id;
+  const usedRuleIds = /* @__PURE__ */ new Set();
+  const packs = /* @__PURE__ */ new Map();
+  const add = (i) => items.push(i);
+  const claim = (f) => claimed.add(f);
+  if (fmt.format === "atticus") {
+    const op = fmt.orgPack;
+    const theirs = await loadOrgPack(join9(dir, ...op.split("/")));
+    const bad = new Set(theirs.problems.map((x) => x.file));
+    for (const x of theirs.problems)
+      problems.push(`${op}/${x.file}: ${x.path ? `${x.path}: ` : ""}${x.message}`);
+    const adoptable = /^(checklists|patterns|dialects|agents|process)\//;
+    for (const f of files.filter((f2) => f2.startsWith(`${op}/`))) {
+      claim(f);
+      const rel = f.slice(op.length + 1);
+      add({
+        id: `atticus-orgpack:${f}`,
+        kind: "atticus-orgpack",
+        path: f,
+        title: rel,
+        action: "link",
+        reason: adoptable.test(rel) ? "Their org-pack file, read as it is (federation keeps full fidelity); adopt to own a copy." : "Part of their org pack's identity (pack, roles, profiles, sources): read for federation, never copied.",
+        confidence: bad.has(rel) ? "medium" : "high",
+        translated: true,
+        ...adoptable.test(rel) ? { artifact: { path: `org-pack/${rel}`, content: await read(f) } } : {}
+      });
+    }
+    const catalogRel = theirs.sources.layout.catalog;
+    const cat = files.filter((f) => f.startsWith(`${catalogRel}/`));
+    if (cat.length) {
+      cat.forEach(claim);
+      const kinds = /* @__PURE__ */ new Map();
+      for (const f of cat.filter((f2) => f2.startsWith(`${catalogRel}/generated/`))) {
+        const k = f.split("/")[catalogRel.split("/").length + 1] ?? "other";
+        kinds.set(k, (kinds.get(k) ?? 0) + 1);
+      }
+      const n = [...kinds.values()].reduce((a, b) => a + b, 0);
+      add({
+        id: `atticus-catalog:${catalogRel}`,
+        kind: "atticus-catalog",
+        path: catalogRel,
+        title: `${n} catalog records (${[...kinds.entries()].map(([k, v]) => `${v} ${k}`).join(", ")})`,
+        action: "link",
+        reason: "Federated at full fidelity: every scan adds their records with their origin kept, and local code wins.",
+        confidence: "high",
+        translated: true
+      });
+    }
+    const os2 = fmt.openspec ?? "openspec";
+    const changeDirs = new Set(files.filter((f) => f.startsWith(`${os2}/changes/`) && f.endsWith("/change.yaml")).map((f) => dirname4(f)));
+    for (const cd of [...changeDirs].sort()) {
+      const inside = files.filter((f) => f.startsWith(`${cd}/`));
+      inside.forEach(claim);
+      add({
+        id: `atticus-change:${cd}`,
+        kind: "atticus-change",
+        path: cd,
+        title: cd.split("/").pop(),
+        action: "link",
+        reason: cd.includes("/archive/") ? "An archived change: history, read only." : "Their open change: visible read-only for conflict detection with ours.",
+        confidence: "high",
+        translated: true
+      });
+    }
+  }
+  const os = fmt.openspec ?? (files.some((f) => f.startsWith("openspec/")) ? "openspec" : void 0);
+  if (os) {
+    for (const f of files.filter((f2) => !claimed.has(f2) && f2.startsWith(`${os}/specs/`) && f2.endsWith("/spec.md"))) {
+      claim(f);
+      const cap = f.split("/").slice(-2)[0];
+      add({
+        id: `openspec-spec:${f}`,
+        kind: "openspec-spec",
+        path: f,
+        title: `Living spec ${cap}`,
+        action: o.mode === "adopt" ? "adopt" : "link",
+        reason: o.mode === "adopt" ? "Imported once into our openspec/specs (already OpenSpec: no conversion)." : "Followed as their living spec; adopt to import it into ours.",
+        confidence: "high",
+        translated: true,
+        artifact: {
+          path: o.mode === "adopt" ? `openspec/specs/${prefix}-${cap}/spec.md` : `references/openspec/${prefix}-${cap}.md`,
+          content: await read(f)
+        }
+      });
+    }
+    const changeDirs = new Set(files.filter((f) => !claimed.has(f) && f.startsWith(`${os}/changes/`)).map((f) => f.slice(`${os}/changes/`.length).split("/")).filter((s) => s.length > 1 && s[0] !== "archive").map((s) => `${os}/changes/${s[0]}`));
+    for (const cd of [...changeDirs].sort()) {
+      const inside = files.filter((f) => f.startsWith(`${cd}/`));
+      inside.forEach(claim);
+      const proposal = inside.includes(`${cd}/proposal.md`) ? await read(`${cd}/proposal.md`) : "";
+      const title = /^#\s+(.+)$/m.exec(proposal)?.[1]?.trim() ?? cd.split("/").pop();
+      add({
+        id: `openspec-change:${cd}`,
+        kind: "openspec-change",
+        path: cd,
+        title,
+        action: "link",
+        reason: "Their change in progress: followed read-only so overlaps with our changes show up.",
+        confidence: "high",
+        translated: true,
+        artifact: {
+          path: `references/openspec-changes/${prefix}-${cd.split("/").pop()}.yaml`,
+          content: (0, import_yaml7.stringify)({
+            change: cd.split("/").pop(),
+            title,
+            files: inside.map((f) => f.slice(cd.length + 1))
+          }, { lineWidth: 0 })
+        }
+      });
+    }
+    for (const f of files.filter((f2) => !claimed.has(f2) && f2.startsWith(`${os}/`))) {
+      claim(f);
+      add({
+        id: `openspec-config:${f}`,
+        kind: "openspec-config",
+        path: f,
+        title: f.slice(os.length + 1),
+        action: /\/(archive)\//.test(f) ? "ignore" : "link",
+        reason: /\/schemas\//.test(f) ? "Their OpenSpec workflow schema: Atticus keeps its own org-flow schema; kept as a reference." : /\/archive\//.test(f) ? "An archived change: history only." : "OpenSpec project context, kept as a reference.",
+        confidence: "high",
+        translated: true,
+        artifact: reference("openspec", f, prefix, "OpenSpec configuration or context of the absorbed repo.")
+      });
+    }
+  }
+  for (const f of files.filter((f2) => !claimed.has(f2) && f2.startsWith(".specify/"))) {
+    claim(f);
+    if (f.endsWith("memory/constitution.md")) {
+      const c = parseConstitution(await read(f));
+      if (c.generatedByAtticus) {
+        add({
+          id: `constitution-principle:${f}`,
+          kind: "constitution-principle",
+          path: f,
+          title: "Constitution generated by Atticus",
+          action: "ignore",
+          reason: "Generated by Atticus's own hand-down from an org pack: nothing new to absorb.",
+          confidence: "high",
+          translated: true,
+          sameAs: "the Atticus constitution"
+        });
+        continue;
+      }
+      const packPath = `org-pack/checklists/${prefix}-constitution.yaml`;
+      const pack = {
+        name: `${prefix}-constitution`,
+        description: `Constitution principles absorbed from ${prefix} (Spec Kit).`,
+        drafts: [],
+        items: []
+      };
+      packs.set(packPath, pack);
+      c.principles.forEach((pr, n) => {
+        const draft = translateCriticItem({
+          text: `${pr.title}: ${pr.body.split("\n").join(" ")}`,
+          line: pr.line,
+          ...pr.nonNegotiable ? { severity: "blocking" } : {},
+          sourceId: pr.title
+        }, { prefix, source: `${prefix}:${f}`, layer: "constitution", usedIds: usedRuleIds });
+        draft.rule.title = pr.title;
+        draft.rule.description = pr.body.replace(/\s+/g, " ").trim();
+        const item = {
+          id: `constitution-principle:${f}#${n + 1}`,
+          kind: "constitution-principle",
+          path: f,
+          line: pr.line,
+          title: pr.title,
+          action: o.mode === "link" || o.mode === "ignore" ? o.mode : "adopt",
+          reason: draft.deterministic ? `A constitution-layer rule run by the built-in check ${draft.rule.check.check}; never waived.` : "A constitution-layer rule with an AI check (its words are the prompt); never waived.",
+          confidence: draft.problems.length ? "low" : draft.deterministic ? "high" : "medium",
+          translated: draft.problems.length === 0,
+          artifact: { path: packPath, content: (0, import_yaml7.stringify)(draft.rule, { lineWidth: 0 }) }
+        };
+        if (draft.problems.length)
+          problems.push(`${f} principle ${pr.title}: ${draft.problems.join("; ")}`);
+        pack.drafts.push(draft);
+        pack.items.push(item);
+        add(item);
+      });
+      for (const s of c.sections) {
+        const governance = /governance/i.test(s.title);
+        if (governance) {
+          add({
+            id: `constitution-principle:${f}#${slug(s.title)}`,
+            kind: "constitution-principle",
+            path: f,
+            line: s.line,
+            title: s.title,
+            action: "ignore",
+            reason: "Atticus's governance applies instead: constitution rules are never waived, tightened only, and changed by PR to the org pack.",
+            confidence: "high",
+            translated: true,
+            sameAs: "Atticus constitution governance"
+          });
+          continue;
+        }
+        const draft = translateCriticItem({ text: `${s.title}: ${s.body.split("\n").join(" ")}`, line: s.line, sourceId: s.title }, { prefix, source: `${prefix}:${f}`, layer: "constitution", usedIds: usedRuleIds });
+        draft.rule.title = s.title;
+        draft.rule.severity = "risk";
+        const item = {
+          id: `constitution-principle:${f}#${slug(s.title)}`,
+          kind: "constitution-principle",
+          path: f,
+          line: s.line,
+          title: s.title,
+          action: o.mode === "link" || o.mode === "ignore" ? o.mode : "adopt",
+          reason: "Extra constraints in the constitution, as a constitution-layer risk rule with an AI check.",
+          confidence: "medium",
+          translated: true,
+          artifact: { path: packPath, content: (0, import_yaml7.stringify)(draft.rule, { lineWidth: 0 }) }
+        };
+        pack.drafts.push(draft);
+        pack.items.push(item);
+        add(item);
+      }
+      continue;
+    }
+    if (f.startsWith(".specify/templates/")) {
+      const base = f.split("/").pop().replace(/\.md$/, "");
+      if (/^spec-template$/.test(base)) {
+        const id = slug(`${prefix}-spec`);
+        add({
+          id: `speckit-template:${f}`,
+          kind: "speckit-template",
+          path: f,
+          title: "Spec Kit feature spec template",
+          action: o.mode === "link" || o.mode === "ignore" ? o.mode : "adopt",
+          reason: "Becomes an org-pack change template: a brief skeleton with the same sections.",
+          confidence: "medium",
+          translated: true,
+          artifact: {
+            path: `org-pack/process/change-templates/${id}.md`,
+            content: changeTemplateFrom(id, `${prefix} feature spec`, await read(f))
+          }
+        });
+      } else
+        add({
+          id: `speckit-template:${f}`,
+          kind: "speckit-template",
+          path: f,
+          title: `Spec Kit ${base}`,
+          action: o.mode === "ignore" ? "ignore" : "link",
+          reason: "Atticus hands down plan.md and tasks.md itself; their template is kept as a reference for the build skill.",
+          confidence: "high",
+          translated: true,
+          artifact: reference("speckit-templates", f, prefix, "A Spec Kit template of the absorbed repo.")
+        });
+      continue;
+    }
+    add({
+      id: `speckit-script:${f}`,
+      kind: "speckit-script",
+      path: f,
+      title: f,
+      action: "ignore",
+      reason: "Spec Kit's own machinery: Atticus installs the pinned Spec Kit files through assistant files.",
+      confidence: "high",
+      translated: true,
+      sameAs: "Atticus Spec Kit adapter files"
+    });
+  }
+  const speckitSpecs = files.filter((f) => !claimed.has(f) && /^specs\/[^/]+\//.test(f));
+  if (speckitSpecs.length && (fmt.format === "speckit" || files.some((f) => f.startsWith(".specify/")))) {
+    for (const f of speckitSpecs) {
+      const feature = f.split("/")[1];
+      const name = f.split("/").slice(2).join("/");
+      if (name === "spec.md") {
+        claim(f);
+        const conv = openSpecFrom(feature, await read(f));
+        const adopt2 = o.mode === "adopt";
+        add({
+          id: `speckit-spec:${f}`,
+          kind: "speckit-spec",
+          path: f,
+          title: `Feature spec ${feature}`,
+          action: adopt2 ? "adopt" : o.mode === "ignore" ? "ignore" : "link",
+          reason: adopt2 ? `One-off import into our OpenSpec living specs (${conv.requirements} requirements).` : "A read-only reference: the speckit extractor reads it on every scan; adopt to import it into OpenSpec.",
+          confidence: conv.requirements ? "high" : "low",
+          translated: conv.requirements > 0,
+          artifact: {
+            path: adopt2 ? `openspec/specs/${prefix}-${feature}/spec.md` : `references/specs/${prefix}-${feature}.md`,
+            content: conv.spec
+          }
+        });
+      } else if (/^(plan|tasks|research|quickstart|data-model)\.md$/.test(name)) {
+        claim(f);
+        add({
+          id: `speckit-plan:${f}`,
+          kind: "speckit-plan",
+          path: f,
+          title: `${feature} ${name}`,
+          action: o.mode === "ignore" ? "ignore" : "link",
+          reason: "Repo-level plan: the speckit extractor reads it as planned records and progress when the repo is scanned.",
+          confidence: "high",
+          translated: true,
+          artifact: reference("speckit-plans", f, prefix, "Read by the speckit extractor when the repo is in a manifest.")
+        });
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  const dup = (text2, id) => {
+    const k = bodyKey(text2);
+    const other = seen.get(k);
+    if (!other)
+      seen.set(k, id);
+    return other;
+  };
+  const isSpecKitCommand = (f) => /(^|\/)speckit\.[a-z-]+(\.prompt|\.agent)?\.md$/i.test(f);
+  for (const f of files.filter((f2) => !claimed.has(f2))) {
+    const prompt = /^\.github\/prompts\/.+\.prompt\.md$/i.test(f) || /^\.claude\/commands\/.+\.md$/i.test(f) || PROMPT_DIR.test(f) && /\.md$/i.test(f) && !DOC.test(f);
+    const agent = /^\.github\/agents\/.+\.agent\.md$/i.test(f) || /^\.github\/chatmodes\/.+\.chatmode\.md$/i.test(f) || /^\.claude\/agents\/.+\.md$/i.test(f);
+    const skill = /^\.claude\/skills\/.+\/SKILL\.md$/.test(f) || /^\.github\/instructions\/.+\.instructions\.md$/i.test(f);
+    const instructions = /^(CLAUDE\.md|AGENTS\.md|\.github\/copilot-instructions\.md)$/.test(f);
+    if (!prompt && !agent && !skill && !instructions)
+      continue;
+    claim(f);
+    const text2 = await read(f);
+    if (isSpecKitCommand(f)) {
+      add({
+        id: `speckit-command:${f}`,
+        kind: "speckit-command",
+        path: f,
+        title: f.split("/").pop(),
+        action: "ignore",
+        reason: "A Spec Kit command: Atticus generates the Spec Kit-compatible commands itself.",
+        confidence: "high",
+        translated: true,
+        sameAs: "Atticus Spec Kit commands"
+      });
+      continue;
+    }
+    const id = `${prompt ? "prompt" : agent ? "agent" : skill ? "skill" : "instructions"}:${f}`;
+    const same = dup(text2, id);
+    if (prompt) {
+      const t = promptToCommand(f, text2, prefix);
+      add({
+        id,
+        kind: "prompt",
+        path: f,
+        title: t.title,
+        action: same ? "ignore" : o.mode === "link" || o.mode === "ignore" ? o.mode : "adopt",
+        reason: same ? `The same prompt as ${same.split(":").slice(1).join(":")} (one command serves both assistants).` : "Becomes an org-pack command, generated for Copilot and Claude Code from one source.",
+        confidence: t.confidence,
+        translated: true,
+        artifact: { path: t.path, content: t.content },
+        ...same ? { sameAs: same } : {}
+      });
+      continue;
+    }
+    const s = toSkill(f, text2, {
+      prefix,
+      owner,
+      source: `${prefix}:${f}`,
+      kind: agent ? "agent" : skill ? "skill" : "instructions"
+    });
+    if (s.problems.length)
+      problems.push(`${f}: ${s.problems.join("; ")}`);
+    add({
+      id,
+      kind: agent ? "agent" : skill ? "skill" : "instructions",
+      path: f,
+      title: s.title,
+      action: same ? "ignore" : instructions ? o.mode === "ignore" ? "ignore" : o.mode === "adopt" ? "adopt" : "link" : o.mode === "link" || o.mode === "ignore" ? o.mode : "adopt",
+      reason: same ? `The same text as ${same.split(":").slice(1).join(":")}.` : instructions ? "Their standing instructions, as a draft skill: linked (they describe their repo), adopt to make them an org skill." : "Becomes an org-pack skill (one source for Copilot instructions and Claude Code skills).",
+      confidence: s.problems.length ? "low" : s.confidence,
+      translated: s.problems.length === 0,
+      artifact: { path: s.path, content: s.content },
+      ...same ? { sameAs: same } : {}
+    });
+  }
+  const compiled = files.filter((f) => /(^|\/)tsp-output\/.+\.(ya?ml|json)$/i.test(f));
+  for (const f of files.filter((f2) => !claimed.has(f2) && /\.tsp$/i.test(f2))) {
+    claim(f);
+    const t = typespecReference(f, await read(f), prefix, compiled);
+    add({
+      id: `typespec:${f}`,
+      kind: "typespec",
+      path: f,
+      title: t.title,
+      action: o.mode === "adopt" ? "adopt" : o.mode === "ignore" ? "ignore" : "link",
+      reason: compiled.length ? "A TypeSpec contract: kept as a reference with its operations and models; its compiled OpenAPI is absorbed as a schema for intake." : "A TypeSpec contract: kept as a reference with its operations and models. No compiled OpenAPI is in the repo: run tsp compile . there and absorb again for intake to read it.",
+      confidence: "high",
+      translated: true,
+      artifact: { path: t.path, content: t.content }
+    });
+  }
+  for (const f of files.filter((f2) => !claimed.has(f2))) {
+    const text2 = /\.(ya?ml|json)$/i.test(f) ? await read(f) : "";
+    const kind = text2 ? schemaKind(f, text2) : void 0;
+    if (!kind)
+      continue;
+    claim(f);
+    const t = schemaReference(f, text2, kind, prefix);
+    const adopt2 = o.mode === "adopt";
+    add({
+      id: `schema:${f}`,
+      kind: "schema",
+      path: f,
+      title: `${t.title} (${kind})`,
+      action: adopt2 ? "adopt" : o.mode === "ignore" ? "ignore" : "link",
+      reason: adopt2 ? "Copied into inputs/specs/ so intake reads it on every scan." : "Kept as a reference; copy it into inputs/specs/ (adopt) for intake to read it.",
+      confidence: "high",
+      translated: true,
+      artifact: adopt2 ? { path: `inputs/specs/${prefix}/${f}`, content: text2 } : { path: t.path, content: t.content }
+    });
+  }
+  for (const f of files.filter((f2) => !claimed.has(f2) && CRITIC_PATH.test(f2) && !DOC.test(f2))) {
+    const text2 = await read(f);
+    const list = /\.ya?ml$/i.test(f) ? yamlItems(text2) : /\.md$/i.test(f) ? markdownItems(text2) : void 0;
+    if (!list || list.length < 2)
+      continue;
+    claim(f);
+    const fileSlug = slug(f.replace(/\.[a-z]+$/i, "").split("/").pop());
+    const packPath = `org-pack/checklists/${prefix}-${fileSlug}.yaml`;
+    const pack = {
+      name: slug(`${prefix}-${fileSlug}`),
+      description: `Checklist absorbed from ${prefix}: ${f}.`,
+      drafts: [],
+      items: []
+    };
+    packs.set(packPath, pack);
+    list.forEach((ci, n) => {
+      const draft = translateCriticItem(ci, {
+        prefix,
+        source: `${prefix}:${f}`,
+        layer: "org",
+        usedIds: usedRuleIds
+      });
+      if (draft.problems.length)
+        problems.push(`${f}:${ci.line}: ${draft.problems.join("; ")}`);
+      const item = {
+        id: `critic-rule:${f}#${n + 1}`,
+        kind: "critic-rule",
+        path: f,
+        line: ci.line,
+        title: draft.rule.title,
+        action: o.mode === "link" || o.mode === "ignore" ? o.mode : "adopt",
+        reason: draft.deterministic ? `Maps to the built-in check ${draft.rule.check.check}: a deterministic ${draft.rule.severity} rule.` : `No built-in check asks this: an AI rule on the ${draft.rule.lens} lens (${draft.rule.severity}, a guess to review).`,
+        confidence: draft.problems.length ? "low" : draft.confidence,
+        translated: draft.problems.length === 0,
+        artifact: { path: packPath, content: (0, import_yaml7.stringify)(draft.rule, { lineWidth: 0 }) }
+      };
+      pack.drafts.push(draft);
+      pack.items.push(item);
+      add(item);
+    });
+  }
+  const code = [];
+  for (const f of files.filter((f2) => !claimed.has(f2))) {
+    if (DOC.test(f)) {
+      add({
+        id: `doc:${f}`,
+        kind: "doc",
+        path: f,
+        title: f,
+        action: "ignore",
+        reason: "About the repo itself (readme, licence, changelog): nothing to absorb.",
+        confidence: "high",
+        translated: false
+      });
+      continue;
+    }
+    if (CODE.test(f) || !/\.(md|ya?ml|json|txt)$/i.test(f)) {
+      code.push(f);
+      continue;
+    }
+    if (/\.md$/i.test(f) && CRITIC_PATH.test(f)) {
+      const t = promptToCommand(f, await read(f), prefix);
+      add({
+        id: `prompt:${f}`,
+        kind: "prompt",
+        path: f,
+        title: t.title,
+        action: o.mode === "link" || o.mode === "ignore" ? o.mode : "adopt",
+        reason: "A review prompt without checklist items: becomes an org-pack command.",
+        confidence: "medium",
+        translated: true,
+        artifact: { path: t.path, content: t.content }
+      });
+      continue;
+    }
+    add({
+      id: `other:${f}`,
+      kind: "other",
+      path: f,
+      title: f,
+      action: "ignore",
+      reason: "Absorb couldn't tell what this is; adopt or link it by hand if it matters.",
+      confidence: "low",
+      translated: false
+    });
+  }
+  if (code.length)
+    add({
+      id: `code:${code.length}-files`,
+      kind: "code",
+      path: ".",
+      title: `${code.length} code and build files`,
+      action: "ignore",
+      reason: "Code is read by the scan when the repo is in a repos manifest, not absorbed.",
+      confidence: "high",
+      translated: false
+    });
+  for (const [path, pk] of packs) {
+    const rules = pk.drafts.filter((_, i) => pk.items[i].action === "adopt").map((d) => d.rule);
+    if (rules.length)
+      for (const x of packFor(pk.name, pk.description, rules).problems)
+        problems.push(`${path}: ${x}`);
+  }
+  const summary = summarise(items);
+  const linkish = items.some((i) => i.action === "link");
+  const entry = {
+    id: o.id,
+    url: opened.url,
+    format: fmt.format,
+    ...o.ref ? { ref: o.ref } : {},
+    mode: o.mode ?? (linkish ? "link" : "adopt")
+  };
+  const result = {
+    id: o.id,
+    format: fmt.format,
+    sourceDir: dir,
+    items,
+    summary,
+    entry,
+    files: [],
+    problems,
+    ms: 0,
+    sourceFiles: Object.fromEntries(await Promise.all(files.map(async (f) => [f, sha256(await readFile4(join9(dir, f)))])))
+  };
+  if (!o.dryRun) {
+    const out = join9(p.proposalsDir, "absorb", o.id);
+    result.files = await writeProposal(out, result, packs);
+    result.proposal = toPosix(`${p.proposalsRel}/absorb/${o.id}`);
+  }
+  result.ms = Math.round(performance.now() - t0);
+  return result;
+}
+function summarise(items) {
+  const translatable = items.filter((i) => !NOT_TRANSLATABLE.has(i.kind));
+  const translated = translatable.filter((i) => i.translated).length;
+  const byAction = { adopt: 0, link: 0, ignore: 0 };
+  const byKind = {};
+  for (const i of items) {
+    byAction[i.action]++;
+    byKind[i.kind] = (byKind[i.kind] ?? 0) + 1;
+  }
+  return {
+    items: items.length,
+    translatable: translatable.length,
+    translated,
+    translatedPercent: translatable.length ? Math.round(translated / translatable.length * 1e3) / 10 : 100,
+    byAction,
+    byKind
+  };
+}
+async function writeProposal(out, r, packs) {
+  await rm3(out, { recursive: true, force: true });
+  const files = /* @__PURE__ */ new Map();
+  for (const i of r.items) {
+    if (!i.artifact || i.action === "ignore")
+      continue;
+    if (packs.has(i.artifact.path))
+      continue;
+    const path = i.action === "link" && !i.artifact.path.startsWith("references/") ? `references/${i.kind}/${i.artifact.path.replace(/^org-pack\//, "")}` : i.artifact.path;
+    if (!files.has(path))
+      files.set(path, i.artifact.content);
+  }
+  for (const [path, pk] of packs) {
+    const rules = pk.drafts.filter((_, n) => pk.items[n].action === "adopt").map((d) => d.rule);
+    if (rules.length)
+      files.set(path, packFor(pk.name, pk.description, rules).content);
+  }
+  files.set("org-pack/sources.absorbed.yaml", sourcesEntry(r));
+  files.set("SUMMARY.md", summaryMd(r));
+  files.set("PR.md", prMd(r));
+  files.set("inventory.json", `${JSON.stringify({
+    id: r.id,
+    format: r.format,
+    entry: r.entry,
+    summary: r.summary,
+    items: r.items.map(({ artifact, ...i }) => ({
+      ...i,
+      ...artifact ? { artifact: artifact.path } : {}
+    })),
+    sources: r.sourceFiles
+  }, null, 2)}
+`);
+  for (const [rel, text2] of files) {
+    const full = join9(out, ...rel.split("/"));
+    await mkdir5(dirname4(full), { recursive: true });
+    await writeFile5(full, text2, "utf8");
+  }
+  return [...files.keys()].sort();
+}
+function sourcesEntry(r) {
+  return `# Add this entry under absorbed: in org-pack/sources.yaml (in the same pull request).
+${(0, import_yaml7.stringify)({ absorbed: [r.entry] }, { lineWidth: 0 })}`;
+}
+var cell = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+function summaryMd(r) {
+  const s = r.summary;
+  return [
+    `# Absorb ${r.id}`,
+    "",
+    `Format: ${r.format}. ${s.items} items: ${s.byAction.adopt} adopt, ${s.byAction.link} link, ${s.byAction.ignore} ignore. Translated: ${s.translated} of ${s.translatable} (${s.translatedPercent}%).`,
+    "",
+    "| Item | Kind | Action | Confidence | Reason | Artifact |",
+    "| --- | --- | --- | --- | --- | --- |",
+    ...r.items.map((i) => `| ${cell(i.path + (i.line ? `:${i.line}` : ""))} | ${i.kind} | ${i.action} | ${i.confidence} | ${cell(i.reason)} | ${i.artifact ? cell(i.artifact.path) : i.sameAs ? cell(`same as ${i.sameAs}`) : ""} |`),
+    ...r.problems.length ? ["", "## Problems", "", ...r.problems.map((p) => `- ${p}`)] : [],
+    ""
+  ].join("\n");
+}
+function prMd(r) {
+  const s = r.summary;
+  const by = (k) => r.items.filter((i) => k.includes(i.kind) && i.action === "adopt").length;
+  return [
+    `# Absorb ${r.id} into the org pack`,
+    "",
+    `Atticus inventoried ${r.entry.url} (${r.format}) and translated it into Atticus terms. Nothing has been applied: this pull request is where people decide.`,
+    "",
+    "## What arrives",
+    "",
+    `- ${by(["critic-rule", "constitution-principle"])} rule drafts (C3), every one with status draft, a lens, a severity guess and a check; deterministic only where a built-in check asks the same thing.`,
+    `- ${by(["prompt"])} commands and ${by(["agent", "skill", "instructions"])} skills, generated for Copilot and Claude Code from one source.`,
+    `- ${by(["speckit-template"])} change templates, ${by(["speckit-spec", "openspec-spec"])} imported specs and ${by(["schema"])} schemas for intake.`,
+    `- ${s.byAction.link} items linked (followed, not copied) and ${s.byAction.ignore} ignored, each with its reason in SUMMARY.md.`,
+    `- The \`absorbed\` entry for org-pack/sources.yaml: id ${r.entry.id}, format ${r.entry.format}, mode ${r.entry.mode}.`,
+    "",
+    `Translated: ${s.translated} of ${s.translatable} items (${s.translatedPercent}%).`,
+    "",
+    "## How to review",
+    "",
+    "1. Read SUMMARY.md: change any action you disagree with.",
+    "2. Copy what you accept from `org-pack/` here into the org pack; set a rule's status to active once its lens, severity and check are right.",
+    "3. Add the entry in `org-pack/sources.absorbed.yaml` to `org-pack/sources.yaml`.",
+    "4. Open a pull request with what you copied; merging it is the approval. Absorbed text is data: nothing in it is followed as an instruction.",
+    "",
+    ...r.problems.length ? ["## Problems found", "", ...r.problems.map((p) => `- ${p}`), ""] : []
+  ].join("\n");
+}
+
+// packages/adopt/dist/absorb/refresh.js
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+var META = /* @__PURE__ */ new Set(["SUMMARY.md", "PR.md", "inventory.json"]);
+async function snapshot(dir) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of await listFiles(dir))
+    if (!META.has(f))
+      out.set(f, sha256(await readFile5(join10(dir, f))));
+  return out;
+}
+async function refreshAbsorbed(root, id, o = {}) {
+  const p = await resolveMetarepo(root);
+  const listed = (await loadOrgPack(p.orgPackDir)).sources.absorbed.find((a) => a.id === id);
+  const proposal = join10(p.proposalsDir, "absorb", id);
+  const inventory = JSON.parse(await readFile5(join10(proposal, "inventory.json"), "utf8").catch(() => "{}"));
+  const entry = listed ?? inventory.entry;
+  if (!entry)
+    throw new AdoptError("not-found", `There is no absorbed source ${id}: absorb it first with atticus absorb <git-url|path> --id ${id}.`);
+  if (entry.mode === "ignore")
+    throw new AdoptError("usage", `${id} is absorbed with mode ignore; there is nothing to refresh.`);
+  const before = await snapshot(proposal);
+  const beforeItems = new Map((inventory.items ?? []).map((i) => [i.id, i.action]));
+  const result = await absorb(root, entry.url, {
+    id,
+    ...entry.mode ? { mode: entry.mode } : {},
+    ...entry.ref ? { ref: entry.ref } : {},
+    ...o.git ? { git: o.git } : {}
+  });
+  const after = await snapshot(proposal);
+  const afterItems = new Map(result.items.map((i) => [i.id, i.action]));
+  const sorted = (xs) => [...xs].sort();
+  const diff = (a, b) => ({
+    added: sorted([...b.keys()].filter((f) => !a.has(f))),
+    removed: sorted([...a.keys()].filter((f) => !b.has(f))),
+    changed: sorted([...b.keys()].filter((f) => a.has(f) && a.get(f) !== b.get(f)))
+  });
+  return {
+    id,
+    entry: { ...entry },
+    from: listed ? "sources.yaml" : "proposal",
+    result,
+    source: diff(new Map(Object.entries(inventory.sources ?? {})), new Map(Object.entries(result.sourceFiles))),
+    files: diff(before, after),
+    items: {
+      added: sorted([...afterItems.keys()].filter((i) => !beforeItems.has(i))),
+      removed: sorted([...beforeItems.keys()].filter((i) => !afterItems.has(i))),
+      changed: [...afterItems].filter(([i, a]) => beforeItems.has(i) && beforeItems.get(i) !== a).map(([i, to]) => ({ id: i, from: beforeItems.get(i), to })).sort((a, b) => a.id.localeCompare(b.id))
+    }
+  };
+}
+async function refreshAllAbsorbed(root, o = {}) {
+  const p = await resolveMetarepo(root);
+  const linked = (await loadOrgPack(p.orgPackDir)).sources.absorbed.filter((a) => a.mode === "link").sort((a, b) => a.id.localeCompare(b.id));
+  const out = [];
+  for (const a of linked)
+    out.push(await refreshAbsorbed(root, a.id, o));
+  return out;
+}
+
+// packages/adopt/dist/absorb/accept.js
+var import_yaml8 = __toESM(require_dist(), 1);
+import { copyFile, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname5, join as join11, relative as relative3 } from "node:path";
+function targetOf(p, file) {
+  const [head, ...rest] = file.split("/");
+  const base = head === "org-pack" ? p.orgPackDir : head === "openspec" ? p.openspecDir : head === "inputs" ? p.inputsDir : void 0;
+  return base && rest.length ? join11(base, ...rest) : void 0;
+}
+async function acceptAbsorbed(root, id, o = {}, paths) {
+  const p = paths ?? await resolveMetarepo(root);
+  const dir = join11(p.proposalsDir, "absorb", id);
+  const text2 = await readText(join11(dir, "inventory.json"));
+  if (text2 === void 0)
+    throw new AdoptError("not-found", `There is no absorb proposal ${id}. Make it first: atticus absorb <git-url|folder> --id ${id}`);
+  const inv = JSON.parse(text2);
+  const rel = (f) => toPosix(relative3(root, f));
+  const out = {
+    id,
+    proposal: rel(dir),
+    copied: [],
+    same: [],
+    kept: [],
+    linked: inv.items.filter((i) => i.action === "link").length,
+    entry: "already",
+    sourcesFile: rel(join11(p.orgPackDir, "sources.yaml"))
+  };
+  const files = [
+    ...new Set(inv.items.filter((i) => i.action === "adopt" && i.artifact).map((i) => i.artifact))
+  ].sort();
+  for (const f of files) {
+    const to = targetOf(p, f);
+    if (!to)
+      continue;
+    const from = join11(dir, ...f.split("/"));
+    const theirs = await readFile6(from);
+    const ours = await readFile6(to).catch(() => void 0);
+    if (ours && ours.equals(theirs)) {
+      out.same.push(rel(to));
+      continue;
+    }
+    if (ours && !o.replace) {
+      out.kept.push(rel(to));
+      continue;
+    }
+    out.copied.push(rel(to));
+    if (!o.dryRun) {
+      await mkdir6(dirname5(to), { recursive: true });
+      await copyFile(from, to);
+    }
+  }
+  const file = join11(p.orgPackDir, "sources.yaml");
+  const doc = (0, import_yaml8.parseDocument)(await readText(file) ?? "schemaVersion: 1\n");
+  const list = doc.get("absorbed");
+  const entries = (0, import_yaml8.isSeq)(list) ? list.toJSON() : [];
+  const at = entries.findIndex((e) => e.id === inv.entry.id);
+  if (at < 0) {
+    if ((0, import_yaml8.isSeq)(list))
+      list.add(doc.createNode(inv.entry));
+    else
+      doc.set("absorbed", doc.createNode([inv.entry]));
+    out.entry = "added";
+  } else if (o.replace && JSON.stringify(entries[at]) !== JSON.stringify(inv.entry)) {
+    doc.setIn(["absorbed", at], doc.createNode(inv.entry));
+    out.entry = "replaced";
+  }
+  if (out.entry !== "already") {
+    const checked = Sources.safeParse(doc.toJS());
+    if (!checked.success)
+      throw new AdoptError("usage", `sources.yaml would not be valid with ${id}'s entry: ${checked.error.issues[0]?.message ?? "invalid"}`);
+    if (!o.dryRun)
+      await writeFile6(file, doc.toString());
+  }
+  return out;
+}
+
+// packages/adopt/dist/federation.js
+var import_yaml9 = __toESM(require_dist(), 1);
+import { readdir as readdir4, readFile as readFile7 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join12, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var REMOTE2 = /^[a-z][a-z0-9+.-]*:\/\//i;
+var SCP2 = /^[^/\\]+@[^:/\\]+:/;
+async function federatedSources(root, paths) {
+  const p = paths ?? await resolveMetarepo(root);
+  const op = await loadOrgPack(p.orgPackDir);
+  const out = [];
+  for (const a of op.sources.absorbed) {
+    if (a.format !== "atticus" || a.mode !== "link")
+      continue;
+    const local = a.url.startsWith("file://") ? fileURLToPath2(a.url) : REMOTE2.test(a.url) || SCP2.test(a.url) ? void 0 : isAbsolute3(a.url) ? a.url : resolve6(root, a.url);
+    const copy = join12(p.stateDir, "absorbed", a.id);
+    if (local && await isDir(local) && !await isDir(join12(local, "objects")))
+      out.push({ id: a.id, dir: local });
+    else if (await isDir(copy))
+      out.push({ id: a.id, dir: copy });
+  }
+  return out;
+}
+async function federatedChanges(sources) {
+  const out = [];
+  for (const s of sources) {
+    const orgPack = await isDir(join12(s.dir, "org-pack")) ? join12(s.dir, "org-pack") : join12(s.dir, ".atticus", "org-pack");
+    const layout = await readLayout(orgPack);
+    const changes = join12(s.dir, ...layout.openspec.split("/"), "changes");
+    let names;
+    try {
+      names = (await readdir4(changes, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== "archive").map((d) => d.name).sort();
+    } catch {
+      continue;
+    }
+    for (const n of names) {
+      let text2;
+      try {
+        text2 = await readFile7(join12(changes, n, "change.yaml"), "utf8");
+      } catch {
+        continue;
+      }
+      const r = ChangeLifecycle.safeParse((0, import_yaml9.parse)(text2));
+      if (r.success && r.data.state !== "archived")
+        out.push({ origin: s.id, change: r.data, dir: s.dir });
+    }
+  }
+  return out;
+}
+var both = (a, b) => a.filter((x) => b.includes(x));
+async function federationConflicts(root, o = {}) {
+  const p = o.paths ?? await resolveMetarepo(root);
+  const sources = o.sources ?? await federatedSources(root, p);
+  if (!sources.length)
+    return [];
+  const base = await loadChangeContext(root);
+  const ctx = {
+    ...base,
+    orgPack: await loadOrgPack(p.orgPackDir),
+    records: o.records ?? (await readCatalog(join12(p.catalogDir, "generated"), { cacheRoot: root })).records
+  };
+  const ours = (await changeStore(root).list()).filter((c) => c.state !== "archived");
+  const theirs = await federatedChanges(sources);
+  const mine = await Promise.all(ours.map(async (c) => [c.id, await changeFootprint(ctx, c)]));
+  const out = [];
+  for (const t of theirs) {
+    const fp = await changeFootprint({ ...ctx, root: t.dir }, t.change);
+    for (const [id, m] of mine) {
+      const overlap = {
+        systems: both(m.systems, fp.systems),
+        interfaces: both(m.interfaces.map((x) => x.id), fp.interfaces.map((x) => x.id)),
+        dataStores: both(m.dataStores, fp.dataStores),
+        tables: both(m.tables, fp.tables),
+        records: both(m.records, fp.records),
+        repos: both(m.repos, fp.repos),
+        // Flows both change (ADR 0124 addendum B-change).
+        flows: both(m.flows.filter((x) => x.change !== "read").map((x) => x.id), fp.flows.filter((x) => x.change !== "read").map((x) => x.id))
+      };
+      if (Object.values(overlap).some((v) => v.length > 0))
+        out.push({ changes: [id, `${t.origin}:${t.change.id}`], overlap });
+    }
+  }
+  return out.sort((a, b) => a.changes.join().localeCompare(b.changes.join()));
+}
+
+// packages/adopt/dist/zero-install.js
+import { join as join13 } from "node:path";
+function relocate(text2, orgPackRel) {
+  if (orgPackRel === "org-pack")
+    return text2;
+  return text2.replace(/(^|[^\w./-])org-pack\//g, `$1${orgPackRel}/`);
+}
+async function renderZeroInstall(paths) {
+  const orgPack = await loadOrgPack(paths.orgPackDir);
+  const { commands } = await loadOrgCommands(paths.orgPackDir);
+  return renderAssistantFiles({ orgPack, commands, profile: { kind: "metarepo" } }).map((f) => ({
+    ...f,
+    content: relocate(f.content, paths.orgPackRel),
+    source: relocate(f.source, paths.orgPackRel)
+  }));
+}
+async function zeroInstallFiles(root, o = {}) {
+  const paths = await resolveMetarepo(root);
+  const files = await renderZeroInstall(paths);
+  return { ...await writeAssistantFiles(root, files, o), files };
+}
+function referencedPaths(text2, paths) {
+  const roots = [
+    paths.orgPackRel,
+    paths.layout.catalog,
+    paths.layout.openspec,
+    ".specify",
+    ".atticus"
+  ];
+  const out = /* @__PURE__ */ new Set();
+  for (const m of text2.matchAll(/`([^`\n]+)`/g)) {
+    let t = m[1];
+    if (/\s/.test(t.replace(/<[^>]*>/g, "")))
+      continue;
+    if (!roots.some((r) => t === r || t === `${r}/` || t.startsWith(`${r}/`)))
+      continue;
+    const cut = t.search(/[<*{$]/);
+    if (cut >= 0)
+      t = t.slice(0, t.lastIndexOf("/", cut) + 1);
+    out.add(t.replace(/\/$/, ""));
+  }
+  return [...out].sort();
+}
+async function checkZeroInstall(root, files) {
+  const paths = await resolveMetarepo(root);
+  const problems = [];
+  for (const f of files)
+    for (const ref of referencedPaths(f.content, paths)) {
+      const full = join13(root, ...ref.split("/"));
+      if (!await exists(full) && !await isDir(full))
+        problems.push({ file: f.path, missing: ref });
+    }
+  return problems;
+}
+
+export {
+  AdoptError,
+  toPosix,
+  exists,
+  isDir,
+  readText,
+  sha256,
+  WALK_SKIP,
+  listFiles,
+  listDirs,
+  hashTree,
+  writeNew,
+  copyDir,
+  slug,
+  frontMatter,
+  ATTICUS_DIR,
+  ORG_PACK_DIR,
+  STATE_FOLDERS,
+  isLocalState,
+  readLayout,
+  resolveMetarepo,
+  orgPackDirOf,
+  pathsFor,
+  inPlacePath,
+  REPO_TYPES,
+  typeFromDescription,
+  typeFromFrameworks,
+  detectRepoType,
+  UNASSIGNED,
+  MockRepoListing,
+  reposDiscover,
+  CHECKLISTS_README,
+  STARTER_CHECKLISTS_README,
+  writeStartingPack,
+  ATTICUS_FOLDER_IGNORE,
+  init,
+  SNAPSHOT_FILE,
+  ADOPTED_FILE,
+  detect,
+  takeSnapshot,
+  adopt,
+  unadopt,
+  NOT_TRANSLATABLE,
+  translateCriticItem,
+  markdownItems,
+  yamlItems,
+  packFor,
+  parseConstitution,
+  changeTemplateFrom,
+  openSpecFrom,
+  bodyKey,
+  promptToCommand,
+  toSkill,
+  schemaKind,
+  schemaReference,
+  reference,
+  typespecOutline,
+  typespecReference,
+  openSource,
+  absorb,
+  summarise,
+  refreshAbsorbed,
+  refreshAllAbsorbed,
+  acceptAbsorbed,
+  federatedSources,
+  federatedChanges,
+  federationConflicts,
+  renderZeroInstall,
+  zeroInstallFiles,
+  referencedPaths,
+  checkZeroInstall
+};