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

package/dist/chunk-FV5YFR6I.js

@@ -0,0 +1,540 @@
+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 {
+  isMetarepo,
+  notMetarepo
+} from "./chunk-3G4YI4ZU.js";
+import {
+  upgradeCheck
+} from "./chunk-Y4BRGOJR.js";
+import {
+  ASSISTANT_FORMATS,
+  assistantTier,
+  generateAssistantFiles,
+  readProbes,
+  tierLine
+} from "./chunk-LK44ULGI.js";
+import {
+  BETA_FEATURES,
+  OPENSPEC_PINNED,
+  STORE_MARKER,
+  createOpenSpec,
+  isSupportedVersion,
+  openspecFeatures,
+  openspecHasStores,
+  readStoreMarker
+} from "./chunk-MGVYVW7Q.js";
+import {
+  versionAtLeast
+} from "./chunk-CHC5FKTU.js";
+import {
+  baseClonePath,
+  createGit,
+  isInPlace,
+  loadRepos,
+  remoteDefaultBranch
+} from "./chunk-PGKHJYOB.js";
+import {
+  modelEnvOf,
+  modelSourceWords,
+  modelsByClass
+} from "./chunk-5XDNUJ4P.js";
+import {
+  DEFAULT_PORT,
+  STEP_CLASSES,
+  factsDirOf,
+  loadOpenSpecSettings,
+  loadOrgPack,
+  orgPackDirOf,
+  require_dist,
+  retrievalOf,
+  stepModelsOf
+} from "./chunk-577AJVRS.js";
+import {
+  readLock
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/doctor.js
+import { existsSync } from "node:fs";
+import { access, constants, mkdir, readFile, rm, statfs, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import { delimiter, join } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+function stepModelChoices(rt, env) {
+  if (rt.modes.allowed.includes("model") && rt.adapters.model)
+    return modelsByClass(rt, env);
+  const org = stepModelsOf(rt);
+  const out = {};
+  for (const c of STEP_CLASSES) {
+    const set = env[modelEnvOf(c)]?.trim();
+    out[c] = set && set !== "atticus" ? { stepClass: c, model: set, from: "setting", notes: [] } : org[c] ? { stepClass: c, model: org[c], from: "runtime.yaml", notes: [] } : { stepClass: c, from: "fallback", notes: [] };
+  }
+  return out;
+}
+var stepModelLine = (m) => `${m.stepClass}: ${m.model ?? "the editor's own model"} (${m.from === "fallback" ? m.model ? modelSourceWords("fallback") : "fallback" : m.from === "setting" ? "your setting" : "runtime.yaml"})`;
+async function defaultAssistantFiles(root) {
+  const r = await generateAssistantFiles(root, { check: true });
+  const of = (a) => r.results.filter((x) => x.action === a).map((x) => x.path);
+  return { missing: of("created"), stale: of("updated"), edited: of("kept-edited") };
+}
+async function eachAtOnce(items, f, limit = 8) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await f(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+async function factsCommit(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.verify.yaml`), "utf8").catch(() => void 0);
+  if (!text)
+    return void 0;
+  try {
+    const commit = (0, import_yaml.parse)(text)?.commit;
+    return typeof commit === "string" && commit ? commit : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var MIN_NODE = "22.13.0";
+var MIN_GIT = "2.30.0";
+var GB = 1024 ** 3;
+function defaultPortFree(port) {
+  return new Promise((resolve) => {
+    const s = createServer();
+    s.once("error", () => resolve(false));
+    s.listen(port, "127.0.0.1", () => s.close(() => resolve(true)));
+  });
+}
+async function defaultFreeBytes(dir) {
+  try {
+    const s = await statfs(dir);
+    return s.bavail * s.bsize;
+  } catch {
+    return void 0;
+  }
+}
+function defaultOnPath(env, platform) {
+  const exts = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+  const dirs = (env.PATH ?? env.Path ?? "").split(platform === "win32" ? ";" : delimiter);
+  return (program) => dirs.some((d) => d && exts.some((e) => existsSync(join(d, program + e.toLowerCase())) || existsSync(join(d, program + e))));
+}
+var envName = (env, ...names) => names.find((n) => env[n] !== void 0 && env[n] !== "");
+var PROGRAMS = Object.fromEntries(Object.entries(ASSISTANT_FORMATS).map(([id, f]) => [
+  id,
+  {
+    programs: f.programs,
+    name: id === "copilot" ? "VS Code or IntelliJ (Copilot runs in them)" : `${f.name} (${f.programs.join(" or ")})`
+  }
+]));
+var EDITORS = {
+  vscode: ["code"],
+  intellij: ["idea", "idea64"]
+};
+async function doctorChecks(root, deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform = deps.platform ?? process.platform;
+  const git = deps.git ?? createGit({ timeoutMs: 15e3 });
+  const onPath = deps.onPath ?? defaultOnPath(env, platform);
+  const out = [];
+  const openspecVersion = deps.openspecVersion ?? (async () => {
+    try {
+      return await createOpenSpec({ root }).version();
+    } catch {
+      return void 0;
+    }
+  });
+  const openspecSoon = openspecVersion();
+  const storesSoon = (deps.openspecStores ?? (() => openspecHasStores()))().catch(() => false);
+  const meta = isMetarepo(root);
+  const upgradeSoon = meta ? upgradeCheck(root) : Promise.resolve({ atticus: "", newer: false, pending: [] });
+  upgradeSoon.catch(() => void 0);
+  const node = deps.nodeVersion ?? process.versions.node;
+  out.push({
+    id: "node",
+    label: "Node.js",
+    status: versionAtLeast(node, MIN_NODE) ? "ok" : "fail",
+    detail: `Node ${node} (needs ${MIN_NODE} or later)`,
+    fix: `Install Node ${MIN_NODE} or later (the LTS 22 line), or use the offline bundle, which carries its own.`
+  });
+  const gitConfig = async (key) => {
+    try {
+      return (await git(["config", "--get", key], root)).stdout.trim() || void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  let gitVersion;
+  try {
+    gitVersion = /(\d+\.\d+(?:\.\d+)?)/.exec((await git(["--version"], root)).stdout)?.[1];
+  } catch {
+    gitVersion = void 0;
+  }
+  out.push({
+    id: "git",
+    label: "Git",
+    status: gitVersion && versionAtLeast(gitVersion, MIN_GIT) ? "ok" : "fail",
+    detail: gitVersion ? `git ${gitVersion} (needs ${MIN_GIT} or later)` : "git isn't on PATH",
+    fix: `Install Git ${MIN_GIT} or later and make sure \`git\` runs from a terminal.`
+  });
+  if (gitVersion) {
+    const [name, email, long, crlf] = await Promise.all([
+      gitConfig("user.name"),
+      gitConfig("user.email"),
+      platform === "win32" ? gitConfig("core.longpaths") : void 0,
+      gitConfig("core.autocrlf")
+    ]);
+    out.push({
+      id: "git-identity",
+      label: "Git identity",
+      status: name && email ? "ok" : "warn",
+      detail: name && email ? "user.name and user.email are set" : "user.name or user.email isn't set",
+      fix: 'Set them once: git config --global user.name "Your Name" and git config --global user.email you@example.com. Hand-offs and task runs commit as you.'
+    });
+    if (platform === "win32") {
+      out.push({
+        id: "git-longpaths",
+        label: "Long paths (Windows)",
+        status: long === "true" ? "ok" : "warn",
+        detail: long === "true" ? "core.longpaths is on" : "core.longpaths is off",
+        fix: "Worktrees nest deep: run git config --global core.longpaths true."
+      });
+    }
+    out.push({
+      id: "line-endings",
+      label: "Line endings",
+      status: "ok",
+      detail: crlf ? `core.autocrlf is ${crlf}; Atticus reads files with LF line endings either way` : "core.autocrlf isn't set"
+    });
+  }
+  const osv = await openspecSoon;
+  out.push({
+    id: "openspec",
+    label: "OpenSpec CLI",
+    status: osv && isSupportedVersion(osv) ? "ok" : "fail",
+    detail: osv ? `OpenSpec ${osv} (tested with ${OPENSPEC_PINNED})` : "the bundled OpenSpec CLI didn't run",
+    fix: "Reinstall Atticus (it carries a pinned OpenSpec): npm install -g @maycombhq/atticus from your npm mirror, or with the offline bundle run its install script again."
+  });
+  const hasStores = await storesSoon;
+  const marker = await readStoreMarker(root);
+  const { settings: osSettings, problem: osProblem } = await loadOpenSpecSettings(orgPackDirOf(root));
+  const uses = [
+    marker.marker ? `this metarepo is the store ${marker.marker.id}` : !marker.missing ? `this metarepo has a ${STORE_MARKER} that can't be read` : "",
+    osSettings.stores.length ? `org-pack/openspec.yaml names ${osSettings.stores.length} store${osSettings.stores.length === 1 ? "" : "s"} to read` : "",
+    osSettings.referenceInRepos ? "hand-down adds it to code repos' references" : ""
+  ].filter(Boolean);
+  out.push({
+    id: "openspec-stores",
+    label: "OpenSpec stores (beta)",
+    status: osProblem || !hasStores && uses.length ? "warn" : "ok",
+    detail: osProblem ? `org-pack/${osProblem}` : hasStores ? `${osv ? `OpenSpec ${osv}` : "OpenSpec"} has stores; ${uses.length ? uses.join("; ") : "this metarepo isn't one (optional: atticus upgrade --openspec-store)"}` : uses.length ? `the installed OpenSpec has no stores, but ${uses.join("; ")}` : "the installed OpenSpec has no stores; nothing here uses them",
+    fix: osProblem ? "Fix org-pack/openspec.yaml (ADR 0126); until then Atticus reads no store and hand-down adds no reference." : "Plain OpenSpec can't register this metarepo or read it as a reference until it has stores; Atticus still reads the stores org-pack/openspec.yaml names. Install an Atticus whose pinned OpenSpec has stores (1.14.0 does)."
+  });
+  const features = await (deps.openspecFeatures ?? (() => openspecFeatures()))().catch(() => void 0);
+  if (features) {
+    const has = (f) => features.beta[f].present;
+    const present = BETA_FEATURES.filter(has);
+    out.push({
+      id: "openspec-features",
+      label: "OpenSpec beta features",
+      status: "ok",
+      detail: [
+        `${osv ? `OpenSpec ${osv}` : "OpenSpec"} has ${present.length ? present.join(", ") : "none of them"}`,
+        `through OpenSpec: status, instructions, validate, list, show, archive${has("store") ? ", each store read with openspec list in it" : ""}`,
+        `Atticus's own: the OpenSpec root from the metarepo's layout${has("context") ? " (context --json not used yet)" : ""}, the org-flow schema from the org pack`,
+        `not used: ${["workset", "doctor", "store doctor"].filter((f) => has(f)).join(", ") || "none"}`
+      ].join("; ")
+    });
+  }
+  const proxy = envName(env, "HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy");
+  const noProxyName = envName(env, "NO_PROXY", "no_proxy");
+  const noProxy = noProxyName ? env[noProxyName] : "";
+  const localBypassed = /(^|,)\s*(localhost|127\.0\.0\.1|\*)\s*(,|$)/.test(noProxy);
+  out.push({
+    id: "proxy",
+    label: "Proxy",
+    status: !proxy || localBypassed ? "ok" : "warn",
+    detail: proxy ? `${proxy} is set${noProxyName ? `; ${noProxyName} ${localBypassed ? "includes" : "doesn't include"} localhost` : "; NO_PROXY isn't set"}` : "no proxy variable is set (direct connections)",
+    fix: "Add localhost and 127.0.0.1 to NO_PROXY so tools that honour the proxy (git, npm, assistants) don't send the app's local calls through it."
+  });
+  const caName = envName(env, "NODE_EXTRA_CA_CERTS");
+  let ca;
+  if (caName) {
+    const file = env[caName];
+    const text = await readFile(file, "utf8").catch(() => void 0);
+    ca = {
+      id: "tls",
+      label: "TLS certificates",
+      status: text && /-----BEGIN CERTIFICATE-----/.test(text) ? "ok" : "fail",
+      detail: text ? /-----BEGIN CERTIFICATE-----/.test(text) ? "NODE_EXTRA_CA_CERTS points at a PEM file" : "NODE_EXTRA_CA_CERTS points at a file with no PEM certificate in it" : "NODE_EXTRA_CA_CERTS points at a file that can't be read",
+      fix: "Point NODE_EXTRA_CA_CERTS at your organisation's root certificate in PEM form (ask the desktop or network team for it)."
+    };
+  } else
+    ca = {
+      id: "tls",
+      label: "TLS certificates",
+      status: proxy ? "warn" : "ok",
+      detail: proxy ? "a proxy is set but NODE_EXTRA_CA_CERTS isn't" : "the system's certificates (no extra CA set)",
+      fix: "If your proxy inspects TLS, set NODE_EXTRA_CA_CERTS to your organisation's root certificate (PEM), or Atticus's adapters and plugins can't reach your systems."
+    };
+  out.push(ca);
+  let writable = true;
+  if (meta)
+    try {
+      const dir = join(root, ".atticus");
+      await mkdir(dir, { recursive: true });
+      const probe = join(dir, `.doctor-${process.pid}`);
+      await writeFile(probe, "ok");
+      await rm(probe);
+      await access(root, constants.W_OK);
+    } catch {
+      writable = false;
+    }
+  out.push({
+    id: "writable",
+    label: "Metarepo is writable",
+    status: writable ? "ok" : "fail",
+    detail: writable ? root : `can't write in ${root}`,
+    fix: "Clone the metarepo to a folder you own (not a synced or read-only share)."
+  });
+  const free = await (deps.freeBytes ?? defaultFreeBytes)(root);
+  out.push({
+    id: "disk",
+    label: "Disk space",
+    status: free === void 0 ? "warn" : free >= 2 * GB ? "ok" : free >= 0.5 * GB ? "warn" : "fail",
+    detail: free === void 0 ? "couldn't read free space" : `${(free / GB).toFixed(1)} GB free`,
+    fix: "Base clones and change worktrees need room: free at least 2 GB (about 50 MB per repo, more per worktree)."
+  });
+  const port = await (deps.portFree ?? defaultPortFree)(DEFAULT_PORT);
+  out.push({
+    id: "port",
+    label: `Port ${DEFAULT_PORT}`,
+    status: port ? "ok" : "warn",
+    detail: port ? "free for atticus ui" : "in use (another atticus ui, or another program)",
+    fix: `Stop the other program, or start the app on another port: atticus ui --port 4322.`
+  });
+  const manifest = await loadRepos(root).catch(() => []);
+  const lock = await readLock(root, "scan");
+  const read = [];
+  const unverified = [];
+  const unread = [];
+  const listed = manifest.filter((x) => !x.archived).sort((a, b) => a.id < b.id ? -1 : 1);
+  const commits = await eachAtOnce(listed, (r) => factsCommit(root, r.id));
+  for (const [i, r] of listed.entries()) {
+    const commit = commits[i];
+    if (commit)
+      read.push(`${r.id} at ${commit.slice(0, 12)}`);
+    else if (existsSync(join(factsDirOf(root), `${r.id}.jsonl`)))
+      unverified.push(`${r.id} read, not verified yet`);
+    else
+      unread.push(r.id);
+  }
+  const facts = [
+    ...read,
+    ...unverified,
+    ...unread.length ? [`not read yet: ${unread.join(", ")}`] : []
+  ];
+  out.push({
+    id: "facts-read",
+    label: "Facts read",
+    status: lock?.stale ? "warn" : "ok",
+    detail: [
+      lock ? lock.stale ? `the write started ${lock.startedAt} stopped before it finished` : `a write is running (since ${lock.startedAt})` : "",
+      facts.length ? facts.join("; ") : "no repo is listed yet"
+    ].filter(Boolean).join("; "),
+    fix: lock?.stale ? "Run atticus verify <repo> --write again: every file it writes is whole." : "Read a repo with /atticus-map <repo> in your assistant (or atticus map <repo>), then atticus verify <repo> --write."
+  });
+  const differ = [];
+  const cloned = manifest.filter((x) => !x.archived && !isInPlace(x.url));
+  const remotes = await eachAtOnce(cloned, (r) => remoteDefaultBranch(baseClonePath(root, r.id), git));
+  for (const [i, r] of cloned.entries()) {
+    const remote = remotes[i];
+    if (remote && remote !== r.defaultBranch)
+      differ.push(`${r.id} (manifest ${r.defaultBranch}, remote ${remote})`);
+  }
+  if (manifest.length)
+    out.push({
+      id: "default-branches",
+      label: "Default branches",
+      status: differ.length ? "warn" : "ok",
+      detail: differ.length ? `read from another branch than the remote's default: ${differ.join(", ")}` : "each repo is read from the branch its manifest names",
+      fix: "If the remote's default is the one to read, set defaultBranch in the manifest (or on Set up \u203A Repos), then run atticus workspace sync."
+    });
+  const up = await upgradeSoon;
+  out.push({
+    id: "upgrade",
+    label: "Metarepo version",
+    status: up.newer ? "fail" : up.pending.length ? "warn" : "ok",
+    detail: up.newer ? `upgraded by Atticus ${up.stamp.atticus}; this is ${up.atticus}` : up.pending.length ? `${up.pending.length} upgrade step${up.pending.length === 1 ? "" : "s"} to run` : up.stamp ? `up to date (last upgraded by Atticus ${up.stamp.atticus})` : "up to date",
+    fix: up.newer ? `Install Atticus ${up.stamp.atticus} or later before working in this metarepo (npm install -g @maycombhq/atticus@${up.stamp.atticus} from your npm mirror, or that version's offline bundle).` : "Run atticus upgrade, then commit what it changed in a pull request."
+  });
+  const op = await loadOrgPack(orgPackDirOf(root));
+  out.push({
+    id: "org-pack",
+    label: "Org pack",
+    status: op.problems.length ? "fail" : "ok",
+    detail: op.problems.length ? `${op.problems.length} problem${op.problems.length === 1 ? "" : "s"}` : "valid",
+    fix: "Run atticus orgpack validate and fix each problem it names."
+  });
+  const rt = op.runtime;
+  const assistants = rt.assistants.allowed.filter((a) => PROGRAMS[a]);
+  const found = assistants.filter((a) => PROGRAMS[a].programs.some(onPath));
+  out.push({
+    id: "assistant",
+    label: "AI assistant",
+    status: rt.ai === "off" || !assistants.length || found.length ? "ok" : "warn",
+    detail: rt.ai === "off" ? "AI is off here (runtime.yaml); no assistant needed" : assistants.length ? found.length ? `found: ${found.map((a) => PROGRAMS[a].name).join(", ")}` : `none of ${assistants.map((a) => PROGRAMS[a].name).join(", ")} is on PATH` : "runtime.yaml allows no assistant this check knows",
+    fix: "Hand-off mode runs in your own assistant: install the one runtime.yaml allows, or ask your desktop team. Atticus works without one; AI steps wait for you."
+  });
+  const editors = rt.editors.filter((e) => EDITORS[e]);
+  const editorFound = editors.filter((e) => EDITORS[e].some(onPath));
+  out.push({
+    id: "editor",
+    label: "Editor",
+    status: !editors.length || editorFound.length ? "ok" : "warn",
+    detail: editorFound.length ? `found: ${editorFound.join(", ")}` : editors.length ? `none of ${editors.join(", ")} is on PATH` : "no editor listed in runtime.yaml",
+    fix: "Change worktrees open as VS Code or IntelliJ workspaces: install one, or add its command to PATH."
+  });
+  const probes = await readProbes(root);
+  const tier = assistantTier(rt, { probes: probes.results });
+  const stale = tier.measured?.stale === true;
+  out.push({
+    id: "tier",
+    label: "First read of a repo",
+    status: stale || probes.problems.length ? "warn" : "ok",
+    detail: [tierLine(tier), ...probes.problems.map((p) => `${p}; left out.`)].join(" "),
+    fix: "Run atticus probe and follow what it prints in your assistant: it measures the tier again."
+  });
+  const model = rt.adapters.model;
+  const keyEnv = model && typeof model.settings.keyEnv === "string" ? model.settings.keyEnv : void 0;
+  const modelMode = rt.modes.allowed.includes("model");
+  const named = !!model && model.type !== "mock";
+  out.push({
+    id: "model",
+    label: "How AI steps run",
+    status: rt.ai === "off" || !modelMode || named && (!keyEnv || envName(env, keyEnv)) ? "ok" : "warn",
+    detail: rt.ai === "off" ? "AI is off here (runtime.yaml)" : !modelMode ? rt.modes.allowed.includes("headless-claude-code") ? "AI steps hand off to your assistant, or run in headless Claude Code (--mode headless-claude-code); runtime.yaml doesn't allow Atticus to call a model's API itself" : "AI steps hand off to your assistant; runtime.yaml doesn't allow Atticus to call a model itself" : !named ? "model mode is allowed, but runtime.yaml names no model provider" : keyEnv && !envName(env, keyEnv) ? `model mode with ${model.type}, but ${keyEnv} isn't set on this machine` : `model mode with ${model.type}${typeof model.settings.model === "string" ? ` (${model.settings.model})` : ""}${keyEnv ? `; ${keyEnv} is set` : ""}. Not called here: doctor makes no network call`,
+    fix: !named ? "Name the provider under adapters.model in runtime.yaml (docs/guide/admin.md, Calling a model directly), or leave model mode out of modes.allowed." : `Set the environment variable ${keyEnv ?? "the provider's key variable"} to the key on this machine (never in runtime.yaml), then open a new terminal.`
+  });
+  if (rt.ai !== "off") {
+    const choices = stepModelChoices(rt, env);
+    const notes = STEP_CLASSES.flatMap((c) => choices[c].notes);
+    out.push({
+      id: "step-models",
+      label: "Model for each kind of step",
+      status: notes.length ? "warn" : "ok",
+      detail: ((line) => notes.length ? `${line}. ${notes.join(" ")}` : line)(STEP_CLASSES.map((c) => stepModelLine(choices[c])).join("; ")),
+      fix: "Name a model per kind of step under models in runtime.yaml (read, draft, critic, knowledge, quick), each one models.allowed lists; a person overrides one in their editor's settings. docs/guide/models.md has a default table."
+    });
+  }
+  if (rt.ai !== "off" && meta) {
+    let files;
+    let problem;
+    try {
+      files = await (deps.assistantFiles ?? defaultAssistantFiles)(root);
+    } catch (e) {
+      problem = e instanceof Error ? e.message : String(e);
+    }
+    const parts = files ? [
+      files.missing.length ? `${files.missing.length} missing` : "",
+      files.stale.length ? `${files.stale.length} out of date` : "",
+      files.edited.length ? `${files.edited.length} edited by hand (kept)` : ""
+    ].filter(Boolean) : [];
+    out.push({
+      id: "assistant-files",
+      label: "Slash commands",
+      status: problem || files.missing.length || files.stale.length ? "warn" : "ok",
+      detail: problem ? `couldn't check them: ${problem}` : parts.length ? `${parts.join(", ")}: the /atticus-* commands your assistant runs` : "the /atticus-* commands your assistant runs are there and current",
+      fix: "Run atticus assistant-files, then commit what it wrote in a pull request; a file edited by hand is kept unless you add --force."
+    });
+  }
+  const lexical = "the context engine searches by words and names only";
+  const embed = await (deps.embed ?? (() => import("./chunk-FZL2HNWP.js")))().catch((e) => e);
+  if (embed instanceof Error) {
+    const model2 = retrievalOf(rt).embeddings.model;
+    const off = process.env.ATTICUS_EMBEDDINGS === "off" || model2 === "off";
+    const missing = embed.code === "ERR_MODULE_NOT_FOUND";
+    out.push({
+      id: "embeddings",
+      label: "Embedding model",
+      status: off || missing && model2 === "bundled" ? "ok" : "warn",
+      detail: off ? `off (${process.env.ATTICUS_EMBEDDINGS === "off" ? "ATTICUS_EMBEDDINGS is off for this process" : "retrieval.embeddings.model is off"}); ${lexical}` : !missing ? `@maycombhq/embed couldn't be loaded (${embed.message.split("\n")[0]}), so ${lexical}` : model2 === "bundled" ? `not installed (@maycombhq/embed, an optional plugin), so ${lexical} (BM25 and the graph walk)` : `runtime.yaml names the model ${model2}, but @maycombhq/embed, the optional plugin that runs it, isn't installed, so ${lexical}`,
+      fix: "Search by meaning is an optional plugin. Add it to this install with the plugin zip (atticus-<version>-embeddings-plugin.zip, built with pnpm bundle --embeddings-plugin): run its install script, then node embeddings-plugin/fetch-model.mjs for the model. Or install Atticus from the bundle built with pnpm bundle --with-embeddings, or install @maycombhq/atticus from your npm mirror without --omit=optional (it brings @maycombhq/embed-model and onnxruntime as optional dependencies). Set retrieval.embeddings.model to off to say the organisation doesn't use one. Atticus itself never downloads anything."
+    });
+  } else {
+    const { embeddingState, runtimeAvailable } = embed;
+    const e = await embeddingState(root);
+    const ort = e.setting === "off" ? void 0 : await runtimeAvailable(root);
+    out.push({
+      id: "embeddings",
+      label: "Embedding model",
+      status: e.setting === "off" ? "ok" : e.problem ? e.configured ? "warn" : "ok" : ort ? "ok" : "warn",
+      detail: e.setting === "off" ? `off (${e.problem ?? "runtime.yaml retrieval.embeddings"}); ${lexical}` : e.problem ? `${e.problem}, so ${lexical}` : (
+        // ADR 0124 addendum D-npm: an npm install carries the model's and onnxruntime's
+        // bytes, so the default is ready with nothing fetched.
+        `${ort ? "ready: " : ""}${e.id} (${((e.bytes ?? 0) / 1024 / 1024).toFixed(0)} MB, ${e.licence}), ${e.setting === "bundled" ? "installed with Atticus" : "the folder runtime.yaml names"}, in ${e.dir}; runtime: ${ort ?? `none found, so ${lexical}`}`
+      ),
+      fix: "The model is an optional plugin (@maycombhq/embed-model and its onnxruntime packages, optional dependencies of @maycombhq/atticus on npm). Where the plugin zip added them, run node embeddings-plugin/fetch-model.mjs in the Atticus folder (--list names the files, --from <folder> takes them from your mirror). Otherwise reinstall Atticus from your npm mirror (npm install -g @maycombhq/atticus) or from the offline bundle built with pnpm bundle --with-embeddings; in a checkout of Atticus run pnpm model:fetch; or point retrieval.embeddings.model at a model folder. Set it to off to say the organisation doesn't use one. Atticus itself never downloads anything."
+    });
+  }
+  const live = Object.entries(rt.adapters).filter(([, a]) => a && a.type !== "mock" && a.type !== "manual");
+  out.push({
+    id: "adapters",
+    label: "Outside systems",
+    status: "ok",
+    detail: live.length ? `${live.map(([k, a]) => `${k}: ${a.type}`).join(", ")}; each falls back to steps a person does when it can't be reached` : "every outside system is manual or a mock: Atticus writes steps for a person"
+  });
+  if (meta)
+    return out;
+  return [
+    { id: "metarepo", label: "Metarepo", status: "warn", detail: notMetarepo(root) },
+    ...out.filter((c) => !METAREPO_ONLY.has(c.id))
+  ];
+}
+var METAREPO_ONLY = /* @__PURE__ */ new Set([
+  "openspec-stores",
+  "writable",
+  "facts-read",
+  "default-branches",
+  "upgrade",
+  "org-pack",
+  "tier",
+  "assistant-files",
+  "adapters"
+]);
+async function doctorCommand(root, o, io, deps = {}) {
+  const checks = await doctorChecks(root, deps);
+  const failed = checks.filter((c) => c.status === "fail");
+  const warned = checks.filter((c) => c.status === "warn");
+  if (o.json)
+    io.out(JSON.stringify({ checks, ok: failed.length === 0 }, null, 2));
+  else {
+    const mark = { ok: "[ok]  ", warn: "[warn]", fail: "[FAIL]" };
+    for (const c of checks) {
+      io.out(`${mark[c.status]} ${c.label}: ${c.detail}`);
+      if (c.status !== "ok" && c.fix)
+        io.out(`       ${c.fix}`);
+    }
+    io.out(failed.length ? `${failed.length} to fix before Atticus can work here${warned.length ? `, ${warned.length} to look at` : ""}.` : warned.length ? `Ready, with ${warned.length} thing${warned.length === 1 ? "" : "s"} to look at.` : "Ready: this machine has what Atticus needs.");
+  }
+  return failed.length ? 1 : 0;
+}
+
+export {
+  stepModelChoices,
+  stepModelLine,
+  MIN_NODE,
+  MIN_GIT,
+  doctorChecks,
+  doctorCommand
+};

package/dist/chunk-FZ2E5LGK.js

@@ -0,0 +1,54 @@
+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 {
+  completionOf,
+  handoffDone,
+  openspecCheck,
+  openspecSetup,
+  workspaceOpen,
+  workspacePrune,
+  workspaceSync
+} from "./chunk-APSVL2AI.js";
+import "./chunk-23M2LUYM.js";
+import "./chunk-Y5PZHS4K.js";
+import "./chunk-IDGSU7JF.js";
+import "./chunk-LK44ULGI.js";
+import "./chunk-73VPWF5R.js";
+import "./chunk-J5LHDJU4.js";
+import "./chunk-YXJ4XOHF.js";
+import "./chunk-ROTY5J2L.js";
+import "./chunk-ZE3P35DA.js";
+import "./chunk-7YYEKTYF.js";
+import "./chunk-XEG3FE2R.js";
+import "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  completionOf,
+  handoffDone,
+  openspecCheck,
+  openspecSetup,
+  workspaceOpen,
+  workspacePrune,
+  workspaceSync
+};