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

package/dist/chunk-MQNBEO3N.js

@@ -0,0 +1,2610 @@
+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 {
+  aliasArgv
+} from "./chunk-BXBCMGIQ.js";
+import {
+  VERSION
+} from "./chunk-7RUMD56V.js";
+import {
+  SCHEMA_VERSION,
+  createLog
+} from "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/main.js
+import { parseArgs } from "node:util";
+import { basename, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+var loadAi = () => import("./chunk-2K2ZEJVR.js");
+var runtimeForCli = async (...a) => {
+  await setUpAi();
+  return (await loadAi()).runtimeForCli(...a);
+};
+var gitUser = (...a) => import("./chunk-R3RVFCJ2.js").then((m) => m.gitUser(...a));
+var loadAiSetUp = () => Promise.all([
+  loadAi(),
+  import("./chunk-YLAM4HZH.js"),
+  import("./chunk-EATSD7YD.js"),
+  import("./chunk-UFBKJOWB.js"),
+  import("./chunk-7RGCQ4VZ.js"),
+  import("./chunk-S2FDPN32.js")
+]);
+async function setUpAi() {
+  const [ai, providers, plugins, naysayer, codeTools, draftCheck] = await loadAiSetUp();
+  providers.registerBuiltInModelProviders();
+  plugins.registerModelProviderPlugins();
+  ai.registerToolSource((at) => (req) => draftCheck.bothTools(codeTools.metarepoToolBox(at), draftCheck.draftCheckTool(at, req)));
+  naysayer.registerCodeSearch(codeTools.criticCodeSearch);
+}
+var NO_AI = /* @__PURE__ */ new Set([
+  "next",
+  "runs",
+  "history",
+  "waiting",
+  "mcp",
+  "doctor",
+  "setup",
+  "verify",
+  "baseline",
+  "upgrade",
+  "support",
+  "change list",
+  "estate measure",
+  "estate fresh",
+  "estate shared",
+  "change status",
+  // Reading the questions on file and printing one: files only, no model (question-commands.ts).
+  "questions list",
+  "questions show"
+]);
+var runsNoAi = (group, command) => NO_AI.has(group) || NO_AI.has(`${group} ${command ?? ""}`);
+var loadCommands = () => import("./chunk-NH5QH3WS.js");
+var catalogValidate = (...a) => loadCommands().then((m) => m.catalogValidate(...a));
+var orgPackValidate = (...a) => loadCommands().then((m) => m.orgPackValidate(...a));
+var schemaExport = (...a) => loadCommands().then((m) => m.schemaExport(...a));
+var loadWorkspaceCommands = () => import("./chunk-E25G46RW.js");
+var handoffDone = (...a) => loadWorkspaceCommands().then((m) => m.handoffDone(...a));
+var openspecCheck = (...a) => loadWorkspaceCommands().then((m) => m.openspecCheck(...a));
+var openspecSetup = (...a) => loadWorkspaceCommands().then((m) => m.openspecSetup(...a));
+var workspaceOpen = (...a) => loadWorkspaceCommands().then((m) => m.workspaceOpen(...a));
+var workspacePrune = (...a) => loadWorkspaceCommands().then((m) => m.workspacePrune(...a));
+var workspaceSync = (...a) => loadWorkspaceCommands().then((m) => m.workspaceSync(...a));
+var loadScanCommands = () => import("./chunk-4Y4FY34K.js");
+var catalogDiff = (...a) => loadScanCommands().then((m) => m.catalogDiff(...a));
+var scanCommand = (...a) => loadScanCommands().then((m) => m.scanCommand(...a));
+var loadIndexCommands = () => import("./chunk-LZWVK4YY.js");
+var askCommand = (...a) => loadIndexCommands().then((m) => m.askCommand(...a));
+var impactCommand = (...a) => loadIndexCommands().then((m) => m.impactCommand(...a));
+var indexRebuild = (...a) => loadIndexCommands().then((m) => m.indexRebuild(...a));
+var queryCommand = (...a) => loadIndexCommands().then((m) => m.queryCommand(...a));
+var searchCommand = (...a) => loadIndexCommands().then((m) => m.searchCommand(...a));
+var loadSiteCommands = () => import("./chunk-MKC7P5LD.js");
+var guideCommand = (...a) => loadSiteCommands().then((m) => m.guideCommand(...a));
+var siteBuildCommand = (...a) => loadSiteCommands().then((m) => m.siteBuildCommand(...a));
+var loadBaselineCommands = () => import("./chunk-ZHWSL6SR.js");
+var baselineCommand = (...a) => loadBaselineCommands().then((m) => m.baselineCommand(...a));
+var setupCommand = (...a) => loadBaselineCommands().then((m) => m.setupCommand(...a));
+var loadDigestCommands = () => import("./chunk-WFYHOXTB.js");
+var digestCommand = (...a) => loadDigestCommands().then((m) => m.digestCommand(...a));
+var loadDoctor = () => import("./chunk-MCWWMMLN.js");
+var doctorCommand = (...a) => loadDoctor().then((m) => m.doctorCommand(...a));
+var loadSupport = () => import("./chunk-MV4637YA.js");
+var supportBundleCommand = (...a) => loadSupport().then((m) => m.supportBundleCommand(...a));
+var loadUpgrade = () => import("./chunk-B3UHYXHU.js");
+var upgradeCommand = (...a) => loadUpgrade().then((m) => m.upgradeCommand(...a));
+var loadReconcileCommands = () => import("./chunk-CRQ73DIF.js");
+var aliasCommand = (...a) => loadReconcileCommands().then((m) => m.aliasCommand(...a));
+var reconcileCommand = (...a) => loadReconcileCommands().then((m) => m.reconcileCommand(...a));
+var loadKnowledgeCommands = () => import("./chunk-SINJKQSI.js");
+var coverageCommand = (...a) => loadKnowledgeCommands().then((m) => m.coverageCommand(...a));
+var patternsScan = (...a) => loadKnowledgeCommands().then((m) => m.patternsScan(...a));
+var questionsCommand = (...a) => loadKnowledgeCommands().then((m) => m.questionsCommand(...a));
+var questionsFiles = (...a) => import("./chunk-XPJR74MA.js").then((m) => m.questionsFiles(...a));
+var sourcesAdd = (...a) => loadKnowledgeCommands().then((m) => m.sourcesAdd(...a));
+var sourcesSync = (...a) => loadKnowledgeCommands().then((m) => m.sourcesSync(...a));
+var loadDiagramCommands = () => import("./chunk-Q32Y5T2U.js");
+var diagramLibrary = (...a) => loadDiagramCommands().then((m) => m.diagramLibrary(...a));
+var diagramRender = (...a) => loadDiagramCommands().then((m) => m.diagramRender(...a));
+var loadStubCommands = () => import("./chunk-WGU6NIUV.js");
+var stubCheck = (...a) => loadStubCommands().then((m) => m.stubCheck(...a));
+var stubServe = (...a) => loadStubCommands().then((m) => m.stubServe(...a));
+var loadIntakeCommands = () => import("./chunk-LEHZTKB3.js");
+var intakeAdd = (...a) => loadIntakeCommands().then((m) => m.intakeAdd(...a));
+var intakeList = (...a) => loadIntakeCommands().then((m) => m.intakeList(...a));
+var triageDecide = (...a) => loadIntakeCommands().then((m) => m.triageDecide(...a));
+var triageList = (...a) => loadIntakeCommands().then((m) => m.triageList(...a));
+var loadRunCommands = () => import("./chunk-REWZE2XI.js");
+var assistantFiles = (...a) => loadRunCommands().then((m) => m.assistantFiles(...a));
+var driftCommand = (...a) => loadRunCommands().then((m) => m.driftCommand(...a));
+var specHandDown = (...a) => loadRunCommands().then((m) => m.specHandDown(...a));
+var specHandUp = (...a) => loadRunCommands().then((m) => m.specHandUp(...a));
+var taskHandoff = (...a) => loadRunCommands().then((m) => m.taskHandoff(...a));
+var taskRun = (...a) => loadRunCommands().then((m) => m.taskRun(...a));
+var loadFeatureCommands = () => import("./chunk-EQOSXLK3.js");
+var featureSuggestNames = (...a) => loadFeatureCommands().then((m) => m.featureSuggestNames(...a));
+var loadDomainCommands = () => import("./chunk-OXVVRJDQ.js");
+var domainProfileCommand = (...a) => loadDomainCommands().then((m) => m.domainProfileCommand(...a));
+var loadPlanCommands = () => import("./chunk-FOQXYMOR.js");
+var adoSync = (...a) => loadPlanCommands().then((m) => m.adoSync(...a));
+var changeDraft = (...a) => loadPlanCommands().then((m) => m.changeDraft(...a));
+var planStories = (...a) => loadPlanCommands().then((m) => m.planStories(...a));
+var snowDraft = (...a) => loadPlanCommands().then((m) => m.snowDraft(...a));
+var snowSubmit = (...a) => loadPlanCommands().then((m) => m.snowSubmit(...a));
+var storyBarCommand = (...a) => loadPlanCommands().then((m) => m.storyBarCommand(...a));
+var templatesDraft = (...a) => loadPlanCommands().then((m) => m.templatesDraft(...a));
+var loadTodoCommands = () => import("./chunk-ANCI3LFS.js");
+var executorsCheck = (...a) => loadTodoCommands().then((m) => m.executorsCheck(...a));
+var todoDone = (...a) => loadTodoCommands().then((m) => m.todoDone(...a));
+var todoList = (...a) => loadTodoCommands().then((m) => m.todoList(...a));
+var todoRun = (...a) => loadTodoCommands().then((m) => m.todoRun(...a));
+var todoShow = (...a) => loadTodoCommands().then((m) => m.todoShow(...a));
+var loadSetupCommands = () => import("./chunk-6V3DTQWK.js");
+var absorbCommand = (...a) => loadSetupCommands().then((m) => m.absorbCommand(...a));
+var absorbAcceptCommand = (...a) => loadSetupCommands().then((m) => m.absorbAcceptCommand(...a));
+var absorbRefreshCommand = (...a) => loadSetupCommands().then((m) => m.absorbRefreshCommand(...a));
+var sourcesRefreshCommand = (...a) => loadSetupCommands().then((m) => m.sourcesRefreshCommand(...a));
+var adoptCommand = (...a) => loadSetupCommands().then((m) => m.adoptCommand(...a));
+var initCommand = (...a) => loadSetupCommands().then((m) => m.initCommand(...a));
+var reposDiscoverCommand = (...a) => loadSetupCommands().then((m) => m.reposDiscoverCommand(...a));
+var unadoptCommand = (...a) => loadSetupCommands().then((m) => m.unadoptCommand(...a));
+var zeroInstallCommand = (...a) => loadSetupCommands().then((m) => m.zeroInstallCommand(...a));
+var loadQualityCommands = () => import("./chunk-VYNZED7B.js");
+var ciArchiveGate = (...a) => loadQualityCommands().then((m) => m.ciArchiveGate(...a));
+var ciDrift = (...a) => loadQualityCommands().then((m) => m.ciDrift(...a));
+var ciSnippet = (...a) => loadQualityCommands().then((m) => m.ciSnippet(...a));
+var glossaryAlias = (...a) => loadQualityCommands().then((m) => m.glossaryAlias(...a));
+var glossaryDefine = (...a) => loadQualityCommands().then((m) => m.glossaryDefine(...a));
+var glossaryLink = (...a) => loadQualityCommands().then((m) => m.glossaryLink(...a));
+var glossaryList = (...a) => loadQualityCommands().then((m) => m.glossaryList(...a));
+var glossaryScan = (...a) => loadQualityCommands().then((m) => m.glossaryScan(...a));
+var testsGenerate = (...a) => loadQualityCommands().then((m) => m.testsGenerate(...a));
+var traceCommand = (...a) => loadQualityCommands().then((m) => m.traceCommand(...a));
+var loadInitiativeCommands = () => import("./chunk-WKXOEIOY.js");
+var initiativeCommitment = (...a) => loadInitiativeCommands().then((m) => m.initiativeCommitment(...a));
+var initiativeNew = (...a) => loadInitiativeCommands().then((m) => m.initiativeNew(...a));
+var initiativePlan = (...a) => loadInitiativeCommands().then((m) => m.initiativePlan(...a));
+var initiativeStatus = (...a) => loadInitiativeCommands().then((m) => m.initiativeStatus(...a));
+var requestFromTeam = (...a) => loadInitiativeCommands().then((m) => m.requestFromTeam(...a));
+var loadLearnCommands = () => import("./chunk-UFTQIK2J.js");
+var explainCommand = (...a) => loadLearnCommands().then((m) => m.explainCommand(...a));
+var learnCheck = (...a) => loadLearnCommands().then((m) => m.learnCheck(...a));
+var learnList = (...a) => loadLearnCommands().then((m) => m.learnList(...a));
+var learnStart = (...a) => loadLearnCommands().then((m) => m.learnStart(...a));
+var sandboxCreate = (...a) => loadLearnCommands().then((m) => m.sandboxCreate(...a));
+var loadEvalCommands = () => import("./chunk-NCR24CPV.js");
+var loadBenchCommands = () => import("./chunk-KQK6SQPE.js");
+var benchFetch = (...a) => loadBenchCommands().then((m) => m.benchFetch(...a));
+var benchRun = (...a) => loadBenchCommands().then((m) => m.benchRun(...a));
+var benchSurvey = (...a) => loadBenchCommands().then((m) => m.benchSurvey(...a));
+var benchVerify = (...a) => loadBenchCommands().then((m) => m.benchVerify(...a));
+var loadScanVerifyCommands = () => import("./chunk-U6YKL7SI.js");
+var stageCli = (...a) => import("./chunk-JBSD57N7.js").then((m) => m.stageCli(...a));
+var knowledgeCli = (...a) => import("./chunk-IWZPGIGT.js").then((m) => m.knowledgeCli(...a));
+var defencesScan = (...a) => loadEvalCommands().then((m) => m.defencesScan(...a));
+var evalReport = (...a) => loadEvalCommands().then((m) => m.evalReport(...a));
+var evalRun = (...a) => loadEvalCommands().then((m) => m.evalRun(...a));
+var loadU1Commands = () => import("./chunk-YWZDAZMA.js");
+var conformanceCommand = (...a) => loadU1Commands().then((m) => m.conformanceCommand(...a));
+var loadReleaseCommands = () => import("./chunk-SIUDWWKS.js");
+var outcomeList = (...a) => loadReleaseCommands().then((m) => m.outcomeList(...a));
+var outcomeRecord = (...a) => loadReleaseCommands().then((m) => m.outcomeRecord(...a));
+var releaseEvidenceCommand = (...a) => loadReleaseCommands().then((m) => m.releaseEvidenceCommand(...a));
+var releaseForecastCommand = (...a) => loadReleaseCommands().then((m) => m.releaseForecastCommand(...a));
+var releaseNotesCommand = (...a) => loadReleaseCommands().then((m) => m.releaseNotesCommand(...a));
+var releasePlanCommand = (...a) => loadReleaseCommands().then((m) => m.releasePlanCommand(...a));
+var releaseSecurityCommand = (...a) => loadReleaseCommands().then((m) => m.releaseSecurityCommand(...a));
+var loadUiCommands = () => import("./chunk-KQRYW7OS.js");
+var uiCommand = (...a) => loadUiCommands().then((m) => m.uiCommand(...a));
+var loadCriticCommands = () => import("./chunk-7KXYMC2P.js");
+var critic = (...a) => loadCriticCommands().then((m) => m.critic(...a));
+var criticStats = (...a) => loadCriticCommands().then((m) => m.criticStats(...a));
+var findingAction = (...a) => loadCriticCommands().then((m) => m.findingAction(...a));
+var findings = (...a) => loadCriticCommands().then((m) => m.findings(...a));
+var catalogMigrate = (...a) => loadFeatureCommands().then((m) => m.catalogMigrate(...a));
+var featureLink = (...a) => loadFeatureCommands().then((m) => m.featureLink(...a));
+var featureList = (...a) => loadFeatureCommands().then((m) => m.featureList(...a));
+var featureMerge = (...a) => loadFeatureCommands().then((m) => m.featureMerge(...a));
+var featureName = (...a) => loadFeatureCommands().then((m) => m.featureName(...a));
+var featureShow = (...a) => loadFeatureCommands().then((m) => m.featureShow(...a));
+var featureSpec = (...a) => loadFeatureCommands().then((m) => m.featureSpec(...a));
+var featureSplit = (...a) => loadFeatureCommands().then((m) => m.featureSplit(...a));
+var featureSuggestLinks = (...a) => loadFeatureCommands().then((m) => m.featureSuggestLinks(...a));
+var featureTag = (...a) => loadFeatureCommands().then((m) => m.featureTag(...a));
+var loadChangeCommands = () => import("./chunk-6E2GJANQ.js");
+var changeArchive = (...a) => loadChangeCommands().then((m) => m.changeArchive(...a));
+var changeConflicts = (...a) => loadChangeCommands().then((m) => m.changeConflicts(...a));
+var changeHandoff = (...a) => loadChangeCommands().then((m) => m.changeHandoff(...a));
+var changeList = (...a) => loadChangeCommands().then((m) => m.changeList(...a));
+var changeNew = (...a) => loadChangeCommands().then((m) => m.changeNew(...a));
+var changeReturn = (...a) => loadChangeCommands().then((m) => m.changeReturn(...a));
+var changeStatus = (...a) => loadChangeCommands().then((m) => m.changeStatus(...a));
+var changeSync = (...a) => loadChangeCommands().then((m) => m.changeSync(...a));
+var changeLearn = (...a) => loadChangeCommands().then((m) => m.changeLearn(...a));
+var loadDialectCommands = () => import("./chunk-BQNEHB5U.js");
+var dialectGrade = (...a) => loadDialectCommands().then((m) => m.dialectGrade(...a));
+var dialectKit = (...a) => loadDialectCommands().then((m) => m.dialectKit(...a));
+var dialectTree = (...a) => loadDialectCommands().then((m) => m.dialectTree(...a));
+var dialectNew = (...a) => loadDialectCommands().then((m) => m.dialectNew(...a));
+var dialectRun = (...a) => loadDialectCommands().then((m) => m.dialectRun(...a));
+var dialectTest = (...a) => loadDialectCommands().then((m) => m.dialectTest(...a));
+var loadPluginCommands = () => import("./chunk-CE4S5ZY3.js");
+var pluginTest = (...a) => loadPluginCommands().then((m) => m.pluginTest(...a));
+var pluginPin = (...a) => loadPluginCommands().then((m) => m.pluginPin(...a));
+var pluginAdd = (...a) => loadPluginCommands().then((m) => m.pluginAdd(...a));
+var loadFrameworkCommands = () => import("./chunk-KIWEBM6G.js");
+var frameworksCheck = (...a) => loadFrameworkCommands().then((m) => m.frameworksCheck(...a));
+var frameworksDiscover = (...a) => loadFrameworkCommands().then((m) => m.frameworksDiscover(...a));
+var frameworksKit = (...a) => loadFrameworkCommands().then((m) => m.frameworksKit(...a));
+var frameworksLearn = (...a) => loadFrameworkCommands().then((m) => m.frameworksLearn(...a));
+var frameworksSurvey = (...a) => loadFrameworkCommands().then((m) => m.frameworksSurvey(...a));
+var loadOnboardCommands = () => import("./chunk-NR5T46ZY.js");
+var onboardAccept = (...a) => loadOnboardCommands().then((m) => m.onboardAccept(...a));
+var onboardCheck = (...a) => loadOnboardCommands().then((m) => m.onboardCheck(...a));
+var onboardDraft = (...a) => loadOnboardCommands().then((m) => m.onboardDraft(...a));
+var scanReview = (...a) => loadOnboardCommands().then((m) => m.scanReview(...a));
+var scanSurvey = (...a) => loadOnboardCommands().then((m) => m.scanSurvey(...a));
+var loadRepoTypeCommands = () => import("./chunk-HZYFLEWO.js");
+var loadRepoCommands = () => import("./chunk-ZKUDS7JG.js");
+var loadSpecCommands = () => import("./chunk-C2YGYTU6.js");
+var loadEstateCommands = () => import("./chunk-26DBAGOP.js");
+var onboardEval = (...a) => loadOnboardCommands().then((m) => m.onboardEval(...a));
+var onboardFramework = (...a) => loadOnboardCommands().then((m) => m.onboardFramework(...a));
+var onboardFrameworkAccept = (...a) => loadOnboardCommands().then((m) => m.onboardFrameworkAccept(...a));
+var onboardFrameworkCheck = (...a) => loadOnboardCommands().then((m) => m.onboardFrameworkCheck(...a));
+var HELP = `atticus ${VERSION} (catalog schema v${SCHEMA_VERSION})
+
+Usage:
+  atticus schema export [dir]          Write JSON Schema for every contract and the API's OpenAPI document (default: ./schema)
+  atticus catalog validate <dir>       Check record files: schema, location and canonical form
+          [--fix]                      Rewrite files that aren't in canonical form
+  atticus catalog diff <a> <b>         Compare two catalog folders (exit 1 when they differ)
+  atticus scan [--no-drift]            Scan every repo's base clone and write catalog/generated
+          [--repos a,b]                Only these repos
+          [--full]                     Ignore the scan cache
+          [--dry-run]                  Show what would change; write nothing
+          [--warnings]                 List what the scan left out or couldn't read, not just how many
+          [--ref <branch>]             Scan another branch beside the baseline, into catalog/branches/<branch>/, and say what it changes
+          [--json]                     Print the result as JSON
+  atticus scan survey <repo>           Your assistant reads the repo and drafts its scan settings (folders to leave out, path prefixes, client base URLs); checked against the code [--attempts 3] [--force] [--max-tokens n]
+  atticus scan verify <repo>           Your assistant compares the code with the last scan: what it missed, what it has wrong, a fix for each; checked, kept in proposals/scan/ [--attempts 3] [--json] [--accept] [--max-tokens n]
+  atticus map <repo>                   Read a repo into facts in batches that fit your model, one hand-off at a time, each answer verified at once; for an assistant without file tools (ADR 0124; /atticus-map reads it in one session) [--mode m] [--max-tokens n] [--next] [--resume run] [--force] [--dir path] [--commit sha] [--json]
+          [--estimate]                 Say what the first read costs: the checkout, commit, facts file, source files, tokens, your assistant's tier and the batches at the limit; with housePrefixes in conventions.yaml, it warns of house packages the repo imports that no taught framework covers, with the frameworks learn command for each (ADR 0147)
+          [--gaps]                     Plan a second pass on what the last verify left (files no fact cites, skipped lines, spec operations, entries no flow follows) for a new chat, sized to the session: writes facts/<repo>.gaps.md (ADR 0157)
+          [--copy]                     Print the next batch's prompt to paste into a chat
+          [--answer <file>]            With --copy: read the pasted answer back from a file (- for stdin)
+          [--gaps --part n]            With --gaps: only what is left of part n of the read plan, for a read that stopped in it (ADR 0161); /atticus-map <repo> --part n --gaps in a new chat reads it
+          [--spent <tokens>] [--sessions n] [--part n]  Record what the read took as your assistant reports it, in facts/<repo>.read-plan.yaml beside --estimate's estimate (Atticus can't meter an assistant's tokens; ADR 0141)
+  atticus map --all                    Map or re-map the whole estate in one command (ADR 0161): every repo's read planned at the model's limit, in the onboarding queue's order, fresh repos skipped. Under Copilot you paste one line per part into a new chat and Atticus waits for the facts, verifies them and moves on (s skip, r retry what's left, q stop; it resumes); where runtime.yaml allows model mode it runs unattended. Then the estate is joined once [--max-tokens n] [--stale | --gaps] [--repos a,b] [--dry-run] [--mode model|hand-off] [--max-parts n] [--budget-tokens n] [--idle minutes]
+  atticus verify <repo>                Check the facts your assistant wrote for a repo (/atticus-map) against its code: the claim on each cited line, the quote, references, secrets, coverage; raises the questions it wrote for a person; rejected facts go back to the assistant (ADR 0124) [--dir path] [--commit sha] [--routed a,b] [--skipped] [--json]
+          [--write]                    When nothing is rejected: put the facts in the catalog, the flows in specs/<repo>/, ask about calls nothing joins, and render the map
+          [--verbose]                  With --write: list every record changed and flow written, not only the counts
+  atticus verify --all [--write]       Every repo read so far (each with a facts file), one after another; no model is called
+  atticus verify audit <repo>          Confirm a reproducible random sample of the repo's kept facts and its links, each with its cited lines (right, wrong or unsure); the answers go to facts/<repo>.audit.yaml, a person's record for a pull request (ADR 0148) [--size n] [--seed s] [--answers file] [--right ids] [--wrong ids] [--unsure ids] [--dir path] [--json]
+  atticus verify audit <repo> --report  Precision from the answers, per kind of fact and for links (by how each was joined), with the sample size and a 95% interval; without a repo, every repo audited and the estate [--json]
+  atticus map render <repo> [--json]   Render the repo's map from the catalog: map.md, a page per flow with its sequence diagram, an OpenAPI file per component, under map/<repo>/
+  atticus spec draft <repo>            Your assistant writes the repo's flows, one per trigger, each step cited and checked [--attempts 3] [--resume run] [--force] [--mode m] [--max-tokens n]
+  atticus spec check <repo> [--json]   Check the repo's flows against the catalog, the template and the code; confirms steps on their cited lines
+  atticus estate join [--json]         Join each repo's call-outs to the flows their targets start; writes specs/estate.yaml
+  atticus estate flow <flow> [--depth 5] [--json]  A flow followed across repos, with the data at each crossing
+  atticus estate lineage <flow> <field> [--depth 5] [--json]  Follow a field along a flow to the column it is stored in, or where it breaks
+  atticus join [--json]                Follow each repo's flows into the flows their calls reach, through the calls the repos' verified facts join (verify --write); the same as estate join
+  atticus join measure <reference> [--json]  Measure your map against a reference you write by hand for two or three repos you know (their entries and calls, each call with the repo it should reach): reading recall, and join precision and recall; reads files only (docs/guide/measure.md)
+  atticus estate measure <reference> [--json]  The same as join measure
+  atticus join shared import <their metarepo> --team <id> --system <id>  Bring in another team's Atticus map, read-only: their verified entries (quotes redacted, the deny-list applied) go to shared/<team>/ at their commit, and verify --write joins your calls to that system to them, cited on their lines; files only (docs/guide/shared-maps.md) [--name <team name>] [--commit <sha>] [--json]
+  atticus join shared refresh [<team>] [<folder>]  Import a team's map again from where it came from (a folder inside the metarepo), or the folder given (needed when it was outside); a newer commit replaces the old [--commit <sha>]
+  atticus join shared list [--json]    The shared maps on file: whose, for which system, their commit and entries
+  atticus estate shared import|refresh|list  The same as join shared
+  atticus join contracts [--json]      Compare the payload on both sides of every link (REST calls, gateway hops, topics, calls to outside systems) from the field facts and the specs on file (a repo's own, a consumer's copy, a topic's .proto, Avro, JSON Schema or AsyncAPI, a vendor's or team's taken in through intake): missing and extra fields, required but not sent, types, error statuses, protobuf field numbers; a mapping nobody traced is unconfirmed, never a mismatch; reads files only (ADR 0164)
+  atticus estate contracts [--json]    The same as join contracts
+  atticus estate fresh [--all] [--json]  Which repos' clones have moved past their facts' commit, most stale first: per repo the facts' commit, the clone's, the files changed that the facts cite, the facts to read again and the command to run; local git only, nothing fetched or written (--all lists the fresh ones too)
+  atticus repo-type detect <repo> [--json]   Match a repo against the org pack's repo types by fingerprint, with the evidence for each signal
+  atticus repo-type new <id> --from <repo> [--force]   Draft a repo type from a repo (its build files, dependencies, markers, folders) for you to edit
+  atticus repo-type note <type> | --org-wide [--add "..."]   List a repo type's notes (or the org-wide ones), or add one: what the organisation's terms mean and what must hold, in its own words; each read of a repo is handed them
+  atticus repo-type rules [--save] [--json]   Draft a checklist rule (status draft) from each note that reads as a rule (all, every, must); --save adds the new drafts to org-pack/checklists/org-notes.yaml for review
+  atticus scan review <repo>           What the last scan couldn't read: your assistant gives a verdict on each gap and a rule for code it can read; checked [--gaps] [--attempts 3]
+  atticus query "<query>"              Find records, e.g. "kind:interface via:gateway -has:pattern"
+  atticus query "<words>" --search     Search everything the index holds (records, knowledge items, flows, changes, answered questions, wiki sections, documents), names and ids first [--by words|meaning|both] [--kind k,k] [--limit n] [--json]
+          [--limit n] [--json]         (see docs/query-language.md)
+  atticus context show <id>            One record, flow, step, knowledge item, change, answered question or wiki section in full, with its file
+  atticus context walk <id> [--hops 1] [--kind k,k] [--limit n]  The links from one id, how each was made, at most two hops
+  atticus cites --repo <repo> --path <path>  What cites each line of one file: the flow steps, with the changes in flight on them, and the records (or --file <path on disk>) [--json]
+  atticus context code <id> [--around 6]  The code a fact cites, a few lines around each cited line, from the workspace checkout
+          [--repo r --path p --line n]  (or one line a fact cites)
+  atticus context similar <id> [--kind k,k] [--limit n]  What reads like one id, by the local embedding model: a hint where to look, never a link
+  atticus context grep "<pattern>" [--regex] [--ignore-case] [--repo r] [--paths glob] [--limit n]  The lines of the workspace clones that match, each repo:path:line; .gitignore'd files skipped
+  atticus context files "<glob>" [--repo r] [--limit n]  The clones' files whose paths match a glob
+  atticus context outline <repo> <path>  A file's declarations with their annotations, from its syntax tree; a document's headings
+  atticus context tools [--json]       The read-only tools a step's model may call beside its pack, and their caps
+  atticus context call <tool> --input <json> [--run <run>] [--round n] [--json]  Run one tool call a model made; with --run it is kept in the run's record
+  atticus impact <id>                  What a change to a record reaches, with owners and open questions
+  atticus ask "<question>"             Answer a plain question from the catalog, showing the query it ran
+  atticus setup [--json]               The setup checklist until the catalog is accepted, with a fix for each step
+  atticus baseline                     Accept the as-is catalog as the baseline [--note text] [--site dir]
+  atticus doctor [--json]              Check this machine: Node, Git, OpenSpec, proxy, TLS, disk, port, assistant, and the tier your assistant reads a repo at
+  atticus doctor --counts [--json]     How far the map has got, in counts and flags only (questions, links by how joined, repos read and stale, facts, tokens reported): nothing named, safe to paste
+  atticus probe                        Measure what your assistant can do here (open a file, write one, run a command), so the tier it reads a repo at is measured, not read off runtime.yaml; then /atticus-probe in the assistant (ADR 0124) [--assistant id] [--max-tokens n] [--json]
+  atticus probe answer <code>          Check the assistant's answer (none when it couldn't open the file) and keep what it measured in .atticus/probe/<assistant>.yaml, on this machine only [--pasted] [--max-tokens n] [--json]
+  atticus secret set|check|forget <name>  Keep a model provider's key in this machine's credential store under the name runtime.yaml gives as keyEnv; read from stdin, never printed
+  atticus upgrade [--check|--dry-run]  Bring the metarepo's files up to this version (backs them up first) [--openspec-store: also make it an OpenSpec store, beta]
+  atticus support bundle               Collect versions, checks, counts and the redacted log in a zip [--out f]
+  atticus digest                       What waits on you: hand-offs to revise, blocking findings [--channel c] [--send] [--json]
+  atticus watch [<change>] [--off]     Follow a change without being on it (or stop); with no change, how each one you watch is doing [--json]
+  atticus guide <system> [--json]      A system's guide, generated from the catalog: parts, calls, data, runtime, decisions
+  atticus site build <dir> [--title t]  The read-only catalog site as static files (only systems open to everyone)
+          [--depth n] [--json]
+  atticus index rebuild                Rebuild the local index from the catalog files
+  atticus index embed                  Give every node of the index its vector from the local embedding model (similar in meaning stays off until then)
+  atticus reconcile [diagram...]       Compare draw.io diagrams with the catalog (default: inputs/diagrams)
+          [--json]
+  atticus sources add <type> <location>  Print the sources.yaml entry for a wiki (git, markdown-folder, ado-wiki, ...), or write it [--save]
+          [--id <id>] [--path <folder>] [--ref <branch>] [--submodule] [--kind <k,k>] [--framework <f,f>] [--owner <who>] [--save]
+  atticus sources sync [--source s] [--json]  Read the wikis and copy each to a dated snapshot: pages, stale pages, conflicts with code, document-only facts
+  atticus sources tag <source> [--kind k,k] [--framework f,f] [--owner o]  Tag a knowledge source in sources.yaml (kinds, frameworks, owner)
+  atticus sources estimate [--source s] [--batch-tokens n] [--full] [--json]  What a knowledge scan would cost before it runs: pages, tokens and model calls per source, within each source's maxPages
+  atticus knowledge scan [--source s] [--mode m] [--resume run] [--full] [--batch-tokens n] [--max-tokens n]  Your assistant reads the snapshots into patterns, standards, processes, requests, decisions and constraints; every quote checked. A rescan reads only the pages that changed and says what changed
+  atticus knowledge list [--tag t] [--kind k] [--unverified] [--json]  The knowledge items, by tag and kind
+  atticus knowledge ask "<question>" [--mode m] [--resume run] [--max-tokens n]  An answer from the knowledge items only, citing them
+  atticus knowledge find "<phrase>"   Search every wiki for a term or phrase; your assistant reads the pages that mention it and proposes what isn't a knowledge item yet, each quote checked [--source s] [--mode m] [--resume run] [--json] [--max-tokens n]
+  atticus knowledge keep <item>        Keep a found item as a knowledge item you verified [--find <search>] [--as <kind>] [--set <field=value>] [--note <text>]
+  atticus knowledge finds [--json]     The searches saved, and how many of each were kept
+  atticus knowledge conflicts [--json]  Pages that disagree: what each says, which page applies and who decided (a person's answer, or the code: a fact verified from code that holds one page's value), the page a signal suggests, and the questions still open
+  atticus knowledge verify <item>      Mark a knowledge item right as read: a green tick wherever it shows [--note <text>]
+  atticus knowledge correct <item> --set field=value  Correct an item's details (a list takes a|b|c); the corrected item is what plans read [--note <text>]
+  atticus knowledge reject <item> --note <why>  Mark an item wrong: plans and answers leave it out
+  atticus bench knowledge [--mode m] [--resume run]  Scan the bench's invented wiki, ask its questions, and score both
+  atticus bench design [--mode m] [--resume run]  Read the bench's Figma export, map it against the petclinic estate, and score it
+  atticus sources refresh [--json]     Fetch every absorbed source again and show what changed
+  atticus patterns scan [--json]       Find integration patterns in the wikis and compare them with the org pack
+  atticus coverage [--json]            What the catalog knows per system and area: verified, document-only, unknown
+  atticus questions [--json]           Knowledge gaps and the owner questions that close them
+  atticus questions list [--state open] [--mine] [--json]   The questions in questions/ a step raised for a person,
+          in the order to ask them, each with its owner team; --mine, your teams' only
+  atticus questions show <id> [--json]  One question on file, with its options, evidence and answer
+          (--json on an open target or topics question adds its picks: every repo, system and team --target takes, for the editors' pickers; ADR 0166)
+  atticus questions answer <id> --option <n> | --text "..." | --accept-proposal   Write the answer to the file; prints the rerun
+          [--scope repo|repo-type] [--type <repo type>] [--by who]  (--accept-proposal: the assistant's proposed answer, checked again, as yours)
+          [--match <host pattern or /path/**>]  (a target or hosts answer by rule: it covers every call that matches, the calls found later too)
+          [--target <id> [--add-system vendor|internal] [--name "..."]]  (where a call goes: any repo of the manifest, read or not, any system of the profile or a team in roles.yaml; a vendor or a team with no system yet is added to the profile with --add-system, a file change for review; ADR 0162)
+  atticus questions proposed [--json]  The answers /atticus-propose proposed for open questions, each citation checked (the file, the line, the quote on it); exits 1 while one doesn't check
+  atticus questions sheet [--out <file>]   Every open question in one YAML answer sheet, each with an empty answer:, to answer in one sitting
+  atticus questions sheet --apply <file> [--by who] [--json]   Answer each filled entry as you; skips blanks, refuses one whose question changed since
+  atticus intake add <files...>        Drop documents, specs and diagrams into inputs/inbox for intake
+  atticus intake list [--json]         What intake read from inputs/: kinds, systems, duplicates, versions
+  atticus intake impact <spec> [--json]   A vendor spec against its other version: each change, breaking or not, and the gateway routes, service calls and callers it reaches
+  atticus intake traffic <file> --source apigee|catalog [--from YYYY-MM-DD --to YYYY-MM-DD] [--json]   A traffic export (a file) kept as aggregate counts in evidence/traffic/, client ids, IPs and tokens dropped; the next verify write marks the links it shows used
+  atticus triage [--json]              What needs a person: unknown names, conflicts with code, image edges
+  atticus triage decide <item> <n>     Choose option n for a triage item; writes a curated decision
+          [--reason text]
+  atticus diagram render <view|file>   Draw a view (context, container, data, event, sequence) or a .drawio file
+          [--focus id] [--format mermaid|drawio] [--out file]
+  atticus diagram library <file>       Write the draw.io shape library
+  atticus stub serve <spec|id>         Serve a stub of an API from its spec, or from the catalog (--from-catalog)
+          [--port 4010] [--host 127.0.0.1]
+  atticus stub check <spec>            Which operations have examples to answer with
+  atticus dialect new <name> --from <repo>[,<repo>...]   Scaffold a dialect from sample repos
+  atticus dialect test <name>          Run a dialect's own tests
+  atticus dialect run <name> <repo>    Show the records a dialect produces from one repo [--json]
+  atticus dialect kit [dir]            Export the dialect build kit for an assistant
+  atticus dialect tree <file> [--language l]   Print a file's syntax tree, for syntax matches
+  atticus plugin test|pin <id>         Run a scanner or model-provider plugin against its golden files, sandboxed; or pin its entry file's sha256
+  atticus plugin add <id>              Copy a model-provider plugin Atticus ships (vertex) into the org pack, to review and pin
+  atticus onboard <repo> [--name n] [--attempts 3] [--mode m]   Your assistant drafts a dialect for a repo Atticus can't read; checked, kept as a proposal
+  atticus onboard check <name> --repo <repo>   Check a proposal (drafted, handed off or hand-written)
+  atticus onboard eval <dir> [--mode m] [--json]   Score the assistant's drafts against reference dialects
+  atticus onboard accept <name> [--replace]   Accept a proposal into org-pack/dialects/ (or frameworks/)
+  atticus onboard framework <name> --from <source|jar|tgz> [--users <repo>,...]   Learn a house framework, your assistant drafts what the learner couldn't; checked, kept as a proposal
+          [--attempts 3] [--package a.b] [--mode m] [--no-ai]
+  atticus onboard check framework <name> [--from <source>] [--users <repo>,...]   Check a framework proposal (drafted, handed off or hand-written)
+  atticus onboard accept framework <name> [--replace]   Accept a framework proposal into org-pack/frameworks/
+  atticus frameworks learn <name> --from <repo|jar|tgz>   Learn what a house framework means from its source, JAR or npm package
+          [--package a.b] [--dry-run]  (writes org-pack/frameworks/<name>.yaml)
+  atticus frameworks discover --group <a.b|@scope>[,...]   The house artifacts and npm packages the repos build on, found here
+          [--jars <dir>]... [--learn] [--json]   (.jar and .tgz folders, Maven and Gradle caches, node_modules; never downloads)
+  atticus frameworks check [name]      Run each framework model's own tests; a failing model isn't used
+  atticus frameworks survey [--package <prefix>[,...]]   How the repos use house frameworks, any language [--json]
+  atticus frameworks kit [dir]         Export the framework-model kit for an assistant
+  atticus change new "<title>"         Start a change from a template: --type <type>
+          [--template id] [--id id] [--owner role=a,b]... [--system id]... [--like <archived change>]
+          [--impact <vendor spec>]  (its footprint: what the spec's newer version reaches, see intake impact)
+  atticus change impact <change> [--json]  What the change's target flows break across the estate: each entry or table, who calls or uses it (a link the map guessed: may break, not counted), the fields that stop crossing and the gateway routes to update, each with its owner team; then who calls the callers, up to five hops up
+  atticus change similar "<brief>"     The archived changes nearest a new brief (or --change <id>: a change's own), to start from one with change new --like or change attach --like [--limit n] [--json]
+  atticus domain profile <system>      A system as a domain profile, filled from the catalog [--out file]
+  atticus change feature <change>      The feature stage: your assistant places the change on the estate's flows and features from the brief, stories or a design; checked and criticised every draft until done [--from-figma f.json] [--mode m] [--resume run] [--force] [--context-tokens n] [--whole-context] [--max-tokens n]
+  atticus change architecture <change>  The architecture stage: the target flows (steps added, changed or removed, with fields) as flow deltas; looped the same way [--mode m] [--resume run] [--context-tokens n] [--whole-context] [--max-tokens n]
+  atticus change small <change>        The fast path for a small change (ADR 0113): your assistant places it on the flows, writes its target flows and words its stories in one step; every stage's checks, and the critic at the change type's gate [--mode m] [--resume run] [--force] [--context-tokens n] [--whole-context]
+  atticus change attach <change> <files...>  Attach a spec, screenshot, PDF, email export or document to a change: copied into its inputs/, read and cited by line or page, read by its steps [--replaces inputs/<file>] [--promote inputs/<file>: copy one into general knowledge] [--like <archived change>: attach an earlier change as an example] [--prototype <repo>: compare a prototype with the estate and attach what exists, changes, is new or only a vendor provides] [--json]
+  atticus change draft <change>        Your assistant drafts the proposal, spec and interfaces from the brief and the catalog; checked [--attempts 3] [--force] [--mode m] [--max-tokens n]
+  atticus change status <id> [--json]  State, next step, what blocks it, risk, the PR to merge and test kinds
+  atticus change knowledge <id>        The patterns, standards, decisions, processes, requests and wiki and document sections that apply to the change, picked by each of its stages from the feature stage on and by each task, with near-misses and the pages that disagree (each undecided one asked of a person once); confirm one (later stages that take its kind pick it) or exclude it (they leave it out) [--confirm id] [--exclude id] [--json]
+  atticus change handoff <id> --approve  Open the phase's hand-off PR; merging it approves the gate [--repo]
+                                       (without --approve: say what it would open, send nothing)
+  atticus change sync <id> [--approve]   Read the hand-off PR; a merged PR moves the change on (--approve merges a ready one) and keeps what Atticus drafted beside what merged (stage/<stage>.drafted/, .merged/)
+  atticus change learn [--json]        How much people changed Atticus's drafts: per merged change and stage, lines per file and each story's criteria and fields, and whether it falls over time (from the kept drafts; completes any whose merge you have since pulled)
+  atticus change return <id> --reason "<why>" --approve  Close the hand-off PR and return the change to the product owner
+  atticus change archive <id> [--no-rescan]  Archive a released change and rescan its repos
+  atticus change list [--json]         Every change and its state
+  atticus change export <change> [ado|jira] [--format ado|jira] [--out file.csv] [--area path] [--iteration path]  The change's stories and tasks as a work-item import file: Azure DevOps' CSV (a User Story per story, its Tasks under it, criteria in Acceptance Criteria) or Jira's; a person imports it
+  atticus change conflicts [--json]    Open changes that touch the same systems, records or repos
+  atticus change conform <change> [--repo r] [--ref branch] [--task t] [--latest] [--json]  Does the code do what the design says: scan the branch's commit and check it against the target flows; what is missing, still there or not in the design becomes findings on the conform gate (--latest shows the newest check, scanning nothing)
+  atticus change estimate <change> [--json]  The change's estimate: its size from the target flows, the org pack's ranges summed, and what drives it, each with its source; never a number nobody stands behind
+  atticus change map <change> [--format mermaid|drawio] [--json]  The change's picture: the components, entries and tables its target flows touch, marked + new, \u25C7 modify or \u2715 retire
+  atticus critic <change> [--gate g] [--lens l] [--mode m] [--json] [--max-tokens n]  Review a change at a gate: rule checks, then AI lenses (--mode runs them)
+  atticus critic <change> [--gate g] --resume  Read in the AI lens answers your assistant wrote (hand-off); handoff done does it per lens
+  atticus critic stats [--json]        How often each rule's findings are dismissed or waived
+  atticus findings <change> [--json]   The change's findings by gate and round
+  atticus finding <change> <id> <action>  apply | edit-and-apply | not-relevant | waive | ask (recorded with you; reaches main with the hand-off PR)
+          [--gate g] [--reason text] [--asked-of who] [--edit patch-file]
+  atticus feature list [--json]        Features found in code, named by people or proposed by AI
+  atticus feature show <id> [--json]   A feature's entry points, flow, owner, links and gaps
+  atticus feature name <id> "<name>"   Confirm or correct a feature's name [--description] [--owner]
+  atticus feature tag <id> <tags...>   Tag a feature
+  atticus feature merge <into> <from...>  Merge features
+  atticus feature split <id> <entry-points...>  Split entry points into another feature [--name] [--into]
+  atticus feature link <id> <ref>      Link a work item or page, e.g. ado:1234 [--title]
+  atticus feature suggest-links [--json]  Suggest links between features and work items
+  atticus feature spec <id>            Draft an OpenSpec capability spec from a confirmed feature
+  atticus catalog migrate [--dry-run]  Rewrite catalog files to the current schema version
+  atticus task context <change> <task> [--json|--markdown]  The task's context for an assistant: its story and criteria, the step it implements with today's code, what applies, the knowledge that applies to it (how-tos with their steps, standards, processes, decisions, each with its page, the pages that say the same and those that disagree), the files attached and the files likely to change
+  atticus task run <change> <task>     Run a task with AI [--level plan|draft|pr] [--mode m] [--approve]
+  atticus task <change> <task>         Run one task with your assistant, the same as task run [--level plan|draft|pr] [--mode m] [--approve]
+  atticus spec hand-down <change> <task>  Create the task's Spec Kit feature in its repo [--force]
+  atticus spec hand-up <change> <task>  Read the Spec Kit feature back at the PR [--pr n --pr-url url]
+  atticus drift <change> [--json]      Compare design, repo plans and code
+  atticus assistant-files [--repo id [--change id]] [--force] [--check]  Generate the slash commands, instructions and skills for each assistant runtime.yaml allows (Copilot, Claude Code, Cursor, Gemini CLI, Windsurf, AGENTS.md)
+  atticus feature suggest-names [--mode m]  Ask AI to propose names for detected features
+  atticus plan stories <change>        Write stories, stories.md and tasks.md from the approved design [--force] [--mode m] [--draft: before approval] [--context-tokens n] [--whole-context] [--max-tokens n]
+  atticus stories <change>             The stories stage, the same as plan stories [--force] [--mode m] [--draft] [--context-tokens n] [--whole-context] [--max-tokens n]
+  atticus change needs <change>        Your assistant says what the change needs from the organisation (requests and processes to raise, standards to follow, teams and vendors to involve), for the change, a feature, flow, story or task; each checked against the change's own words [--mode m] [--resume run] [--context-tokens n] [--whole-context] [--max-tokens n]
+  atticus needs [--change id] [--all] [--json]  What changes need from the organisation, open ones first, with lead times and who handles each
+  atticus waiting [--group change|kind] [--filter words] [--json]  What waits on you across every change: questions, open needs, manual steps, findings, knowledge to verify
+  atticus runs [--change id] [--limit n] [--json]  The model runs: what Atticus asked a model, each round, and whether it was answered
+  atticus runs show <run> [--json]     One run: its prompt, its answer and the problems handed back to it
+  atticus history [--change id] [--session id] [--filter words] [--limit n] [--json]  The prompts people sent their assistant here and the responses they got, by session, kept on this machine
+  atticus history show <id> [--json]   One prompt or response, and its pair
+  atticus history add --surface <claude-code|vscode|cli> --kind <prompt|response> [--session id] [--command c] [--change id]  Record one prompt or response, its text read from stdin (the plugin's hooks and VS Code call it)
+  atticus history off                  Stop recording prompts and responses on this machine (kept in .atticus/me.yaml)
+  atticus history on                   Record them again on this machine (runtime.yaml can still turn it off for everyone)
+  atticus needs done <change> <item>   Record a need as done, e.g. with the CTASK number as its note [--for <target>] [--note <text>]
+  atticus needs skip <change> <item> --note <why>  Record a need as not needed, and why [--for <target>]
+  atticus needs reopen <change> <item>  Open a need again [--for <target>]
+                                       (with target flows: the stories stage, a task per changed step with its prompt, requests from knowledge)
+  atticus plan snow <change>           Draft service-desk requests the change needs [--force]
+  atticus plan bar <change>            Measure the story bar [--eval file]
+  atticus plan submit <change>         File the drafted requests (a dry run until you add --approve)
+  atticus ado sync <change>            Create or update work items (a dry run until you add --approve) [--epic id]
+  atticus templates draft              Draft request and work-item templates from wikis, uploads and past tickets [--no-ai]
+  atticus todo [--change id] [--all]   Manual steps waiting for a person
+  atticus todo show <step> [--export text|csv|import]  A manual step: what to do, where, and what it needs
+  atticus todo done <step>             Record a manual step's result [--result k=v]... [--skip --note why]
+  atticus todo run <step> --with <executor>  Run a step with a team's own tool [--approve --inputs sha] [--fill-only]
+  atticus executors check              Ping configured executors and show what each covers
+  atticus init <folder> --platform <p>  Create a new metarepo named after the folder [--from pack] [--owner who] [--openspec-store: also an OpenSpec store, beta]
+  atticus adopt <path>                 Use Atticus in an existing repo; writes only .atticus/ [--platform p] [--name n]
+  atticus unadopt <path>               Remove Atticus from an adopted repo, leaving it as it was
+  atticus repos discover <folder> | --org <org>  Propose repos.manifest.yaml entries [--platform p] [--dry-run]
+  atticus repo add <url|path>          Add one repo to the manifest, with what it is in your own words; with a folder and no --type, its type is read from its files (or, where they say nothing, from what you wrote) [--id x] [--type t] [--owner team] [--system s] [--component c] [--platform p] [--description "what it is"] [--no-description] [--json]
+  atticus repo rename <old> <new>      Move a repo's id with its facts, read plan, reviewed file, questions and catalog records, in one change you review (files moved and rewritten; nothing committed or pushed)
+  atticus repo describe [<repo>]       Say what a repo is, in one line, for a repo that has none (or edit what it says); with no repo, the repos with no description and the drafts waiting for a person [--description "..."] [--accept] [--reject] [--json]
+          [--drafted "..." --cites f:n]  Your assistant hands over the line it drafted, with the lines it read it from; kept unconfirmed until a person confirms it
+  atticus absorb <git-url|path> --id <id>  Translate another team's prompts, agents, checklists, OpenSpec, Spec Kit, TypeSpec or Atticus repo
+          [--mode adopt|link|ignore] [--ref r] [--dry-run]
+  atticus absorb --refresh <id>        Fetch an absorbed source again and update its proposal
+  atticus absorb accept <id>           Copy what the reviewed proposal adopts into the org pack and add its sources.yaml entry [--replace] [--dry-run] [--json]
+  atticus tests generate <change> <story>  Generate tests from a story [--framework id] [--force] [--check] [--mode m]
+  atticus trace <change> [--json] [--csv] [--no-write]  Requirement \u2192 story \u2192 test \u2192 code \u2192 records \u2192 feature
+  atticus release plan <change> [--json]  Deploy order across the repos, why, rollback per step, waits and release sections
+  atticus release forecast <change> [--json]  Forecast ready-to-release day from lead times and the initiative's plan
+  atticus release evidence <change> [--out dir] [--json]  The evidence pack for an approval board or an audit
+  atticus release notes <change> [--audience business|technical] [--json]  Release notes from the brief, interfaces and data
+  atticus release security <change> [--json]  Security review draft: auth, classifications, boundaries, vendors, secrets
+  atticus outcome list [--change id] [--json]  The brief's success measures and the values recorded after release
+  atticus outcome record <change> <measure> --value <v>  Record a measured outcome [--note text]
+  atticus ci drift [repo] --catalog <path>  In a repo's pipeline: compare the repo with the committed catalog
+          [--repo id] [--json [file]] [--junit file] [--summary file] [--warn-only]
+  atticus ci snippet <github|azure|gitlab|jenkins> [--write dir]  Pipeline template for the drift check
+  atticus ci archive-gate <change> [--drift file]...  Whether a change may be archived
+  atticus glossary list|scan [--json]  Business terms from wikis, code and people
+  atticus glossary define <term> "<definition>" [--owner team]  Define a business term, as you
+  atticus glossary link <term> <record-id|schema#field>  Link a term to a catalog record or field
+  atticus glossary alias <term> <name>...  Another name people use for a term
+  atticus initiative new "<title>" --journey <j>  Start an initiative [--id] [--release YYYY-MM-DD] [--epic]
+  atticus initiative plan <id> --target <system>  Plan its changes and commitments [--release d] [--system s]... [--dry-run]
+  atticus initiative status <id>       Critical path, at-risk and slipped commitments
+  atticus initiative request <id> <party>  Send a team a system card and track the reply [--system s]...
+  atticus initiative commit <commitment> <open|at-risk|done|slipped>  Record a commitment's status
+  atticus learn [list] | learn start <role|lesson> | learn check [--answer a] [--lesson l] [--step s]
+                                       Lessons by role in a practice sandbox: list them, start one, check a step
+  atticus sandbox create <dir>         A throwaway practice metarepo
+  atticus commands [--json]            Every command as data: its arguments, options, area and how it runs (for an editor)
+  atticus legacy [--all]               Every command outside the twelve atticus help shows, grouped; atticus legacy <command> runs one exactly as atticus <command> does
+  atticus explain <id|command>         Explain a record, finding, change or command in plain words
+  atticus eval run [--agent a]... [--mode mock|replay|live] [--runs n]  Evaluate AI agents
+  atticus eval report                  The latest eval results and AI quality
+  atticus bench fetch [--repo id] [--batch n] [--cache dir]  Clone the bench's public repos at their pinned commits
+  atticus bench survey [--repo id] [--batch n] [--mode m]  Your assistant drafts each bench repo's scan settings; kept for later runs
+  atticus bench verify [--repo id] [--batch n] [--mode m]  Your assistant verifies each bench repo's scan; kept for bench run to score
+  atticus bench run [--repo id] [--batch n] [--estate e] [--json] [--specs]  Scan each bench repo and score it against its reference; --specs also scores drafted specs against bench/flows and scans each estate's repos together
+  atticus bench facts [<repo>] [--facts file] [--batch n] [--json]  Score the facts your assistant wrote for each bench repo against its reference, per kind, with bench run's matcher
+  atticus bench stories --draft <file> [--facts file] [--json]  Score a drafted user story against its reference story in bench/stories: steps, fields, error cases, invented fields, rubric sections
+  atticus bench stories --change <change> --story <id> [--out file] [--facts file] [--json]  Score the stories the stories stage drafted for a change (its id or folder), converted to one bench story, against bench/stories/<id>.yaml; --out keeps the converted draft
+  atticus defences scan [path] [--all]  Look for instructions hidden in documents and prompts
+  atticus conformance <path> --kind <catalog|org-pack|dialect|plugin|executor>
+                                       Check a catalog, org pack, dialect, plugin or executor against the spec
+  atticus alias "<name>" <id>          Record that a name used in diagrams or documents means a catalog id
+          [--reason text]
+  atticus orgpack owner [<handle>]     Who looks after the org pack: shown, or set in pack.yaml (the rest of the file stays)
+  atticus orgpack validate [dir]       Check an org pack against its schemas (default: <root>/org-pack)
+  atticus orgpack draft                Draft the profile's systems from the knowledge items: the products and vendors the wikis name, with their aliases and owners, each citing its item [--platform <p>] [--json]
+  atticus orgpack accept <platform>    Put the drafted systems into profile.yaml [--only <id,id>] [--verified-only] [--dry-run] [--json]
+  atticus standards propose            Propose each rule of a confirmed standard as a critic check (proposals/checklists/standards.yaml); nothing is enforced [--json]
+  atticus standards accept             Put the proposed checks a person picks into org-pack/checklists/standards.yaml [--only <id,id>] [--dry-run] [--json]
+  atticus openspec setup               Set up OpenSpec with the org-flow schema in the metarepo
+  atticus openspec check               Check the OpenSpec version and validate every change and spec
+  atticus spec seed <repo> [--json]    Propose a repo's starting openspec/specs from its verified flows, as the change openspec/changes/seed-<repo>/: a requirement per flow, a scenario per path and error case, each citing its lines (ADR 0146)
+  atticus spec accept <repo>           Accept the repo's seeded spec: OpenSpec validates it strictly, then archives it into openspec/specs/; the next change modifies it
+  atticus openspec <args...>           Run the bundled OpenSpec CLI in the metarepo with these arguments (openspec isn't on PATH; it ships inside Atticus). status, instructions and show take --change from the only change open when you don't name one
+  atticus handoff done <run-id>        Tell Atticus a hand-off artifact is written; it validates it (a stage's draft: with the stage's checks, its problems listed with their lines until it is clean) [--model m: the model that wrote it, kept in the run record]
+  atticus stage check <change> <stage> <file>  Run a stage's checks on a draft's file and list its problems with their lines; writes nothing (a drafter checks its draft before it hands it in)
+  atticus next [--all] [--json]        The next step to take, its command and slash command, and why; from the files only
+          [--queue]                    The repos to read next, gateways and the repos others call first so links land early, each with its estimated cost, and what each read so far took (ADR 0141)
+  atticus <step> --handoff [--json]    On map, scan survey, scan verify, spec draft, knowledge scan, change feature, change architecture, change small, change draft, stories, change needs, knowledge find, knowledge ask and critic (its lenses one at a time, as a stage offers its critic lenses after each draft): print only the prompt, the result file and the commands that finish it
+  atticus <step> --max-tokens n        On the same steps: the model's limit. The whole prompt fits n tokens (counted as characters / 4, a quarter kept back for the count's error), or the step says before handing off that it can't, with the numbers. The VS Code extension passes its model's limit to every step
+  atticus workspace sync               Clone or update the base clone of every repo in the manifests
+          [--repos a,b]                Only these repos
+          [--from <folder>]            Copy a missing base clone from your own clone of it in that folder: no network, your clone only read
+  atticus workspace open <change>      Create the change's worktrees, repos.yaml and editor workspaces
+          --repos a,b                  The repos the change touches
+  atticus workspace prune <change>     Remove worktrees whose PRs merged or closed
+          [--all] [--force]            All worktrees; also those with uncommitted work
+
+  --root <dir>                         The metarepo (default: the current folder)
+  --by <handle>                        Who is acting (default: the metarepo's Git user, git config user.email)
+  atticus mcp                          Serve read-only tools to an assistant over MCP (stdio): next step, catalog, knowledge, changes, needs (the Claude Code plugin starts it)
+  atticus ui [--port n] [--open]       Start the app on this machine (127.0.0.1); Ctrl+C stops it
+          [--embed vscode]             Let a VS Code panel show the app (the Atticus extension starts it so)
+          [--parent pid]               Stop when that process ends (an editor that started it)
+          [--show-token]               Print the session token, for an assistant or a script (an editor that starts it gets it)
+          [--full]                     Every page a tab of its section, and the menu's More pages open
+  atticus --version                    Print the version
+  atticus --help                       Show this help
+
+Every command is described in docs/guide/commands.md; atticus explain <command> says more.`;
+var HELP_TEXT = HELP;
+var RECORDS_A_PERSON = /* @__PURE__ */ new Set([
+  "knowledge",
+  "needs",
+  "upgrade",
+  "baseline",
+  "digest",
+  "alias",
+  "initiative",
+  "outcome",
+  "glossary",
+  "plan",
+  "ado",
+  "todo",
+  "task",
+  "spec",
+  "feature",
+  "finding",
+  "change",
+  "triage",
+  "handoff"
+]);
+async function readAll(stream) {
+  const chunks = [];
+  for await (const c of stream)
+    chunks.push(typeof c === "string" ? Buffer.from(c) : c);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function num(v) {
+  const n = typeof v === "string" ? Number(v) : NaN;
+  return Number.isInteger(n) && n > 0 ? n : void 0;
+}
+async function main(given, io, o = {}) {
+  const started = Date.now();
+  const argv = aliasArgv(given, positionalsAt(given));
+  const words = argv.filter((a) => !a.startsWith("-")).slice(0, 2);
+  const flags = [
+    ...new Set(argv.filter((a) => a.startsWith("--")).map((a) => a.slice(2).split("=")[0]))
+  ];
+  const rootAt = argv.indexOf("--root");
+  const root = resolve(rootAt >= 0 && argv[rootAt + 1] ? argv[rootAt + 1] : process.cwd());
+  const log = () => isMetarepoRoot(root) ? createLog(root, o.quiet ? { level: "warn" } : {}) : void 0;
+  try {
+    const code = await dispatch(argv, io);
+    log()?.info("command", { command: words.join(" "), flags, code, ms: Date.now() - started });
+    return code;
+  } catch (e) {
+    const l = log();
+    l?.error("crash", e, { command: words.join(" "), flags, ms: Date.now() - started });
+    if (l && e instanceof Error)
+      e.logFile = l.file;
+    throw e;
+  }
+}
+function openspecArgsOf(argv) {
+  const at = argv.indexOf("openspec");
+  const out = [];
+  for (let i = at + 1; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--root") {
+      i++;
+      continue;
+    }
+    if (a.startsWith("--root="))
+      continue;
+    out.push(a);
+  }
+  return out;
+}
+function positionalsAt(argv) {
+  const { tokens } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: OPTIONS,
+    strict: false,
+    tokens: true
+  });
+  return tokens.filter((t) => t.kind === "positional").map((t) => t.index);
+}
+function isMetarepoRoot(root) {
+  return existsSync(join(root, "org-pack")) || existsSync(join(root, ".atticus", "org-pack"));
+}
+async function dispatch(argv, io) {
+  const at = argv.findIndex((a) => a === "--max-tokens" || a.startsWith("--max-tokens="));
+  if (at < 0)
+    return dispatchCommand(argv, io);
+  const raw = argv[at].includes("=") ? argv[at].slice("--max-tokens=".length) : argv[at + 1];
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1e3) {
+    io.err("--max-tokens is a whole number of 1000 or more: the model's limit, which the whole prompt must fit.");
+    return 2;
+  }
+  const { withPromptLimit, PromptTooLong } = await loadAi();
+  try {
+    return await withPromptLimit(n, () => dispatchCommand(argv, io));
+  } catch (e) {
+    if (!(e instanceof PromptTooLong))
+      throw e;
+    io.err(e.message);
+    return 2;
+  }
+}
+var OPTIONS = {
+  help: { type: "boolean", short: "h" },
+  // ADR 0141: what a read took, as the reader reports it (atticus map <repo> --spent).
+  spent: { type: "string" },
+  sessions: { type: "string" },
+  part: { type: "string" },
+  queue: { type: "boolean" },
+  // F10: atticus doctor --counts.
+  counts: { type: "boolean" },
+  version: { type: "boolean", short: "v" },
+  fix: { type: "boolean" },
+  root: { type: "string" },
+  repos: { type: "string" },
+  all: { type: "boolean" },
+  kind: { type: "string" },
+  executor: { type: "string" },
+  fixture: { type: "string" },
+  force: { type: "boolean" },
+  draft: { type: "boolean" },
+  story: { type: "string" },
+  gaps: { type: "boolean" },
+  // ADR 0161: atticus map --all.
+  stale: { type: "boolean" },
+  "max-parts": { type: "string" },
+  "budget-tokens": { type: "string" },
+  idle: { type: "string" },
+  full: { type: "boolean" },
+  "dry-run": { type: "boolean" },
+  json: { type: "boolean" },
+  limit: { type: "string" },
+  filter: { type: "string" },
+  "batch-tokens": { type: "string" },
+  "max-tokens": { type: "string" },
+  // atticus probe (ADR 0124 addendum A-probe).
+  assistant: { type: "string" },
+  pasted: { type: "boolean" },
+  "context-tokens": { type: "string" },
+  "whole-context": { type: "boolean" },
+  search: { type: "boolean" },
+  regex: { type: "boolean" },
+  "ignore-case": { type: "boolean" },
+  paths: { type: "string" },
+  // atticus context (ADR 0107 addendum): the context tools.
+  input: { type: "string" },
+  run: { type: "string" },
+  round: { type: "string" },
+  hops: { type: "string" },
+  line: { type: "string" },
+  around: { type: "string" },
+  depth: { type: "string" },
+  by: { type: "string" },
+  as: { type: "string" },
+  group: { type: "string", multiple: true },
+  channel: { type: "string" },
+  send: { type: "boolean" },
+  site: { type: "string" },
+  reason: { type: "string" },
+  focus: { type: "string" },
+  format: { type: "string" },
+  out: { type: "string" },
+  area: { type: "string" },
+  iteration: { type: "string" },
+  port: { type: "string" },
+  open: { type: "boolean" },
+  "show-token": { type: "boolean" },
+  embed: { type: "string" },
+  parent: { type: "string" },
+  host: { type: "string" },
+  catalog: { type: "string" },
+  "from-catalog": { type: "boolean" },
+  from: { type: "string" },
+  to: { type: "string" },
+  package: { type: "string" },
+  jars: { type: "string", multiple: true },
+  learn: { type: "boolean" },
+  type: { type: "string" },
+  template: { type: "string" },
+  like: { type: "string" },
+  impact: { type: "string" },
+  id: { type: "string" },
+  owner: { type: "string", multiple: true },
+  system: { type: "string", multiple: true },
+  base: { type: "string" },
+  repo: { type: "string" },
+  gate: { type: "string" },
+  lens: { type: "string" },
+  model: { type: "string" },
+  "asked-of": { type: "string" },
+  edit: { type: "string" },
+  description: { type: "string" },
+  title: { type: "string" },
+  name: { type: "string" },
+  attempts: { type: "string" },
+  users: { type: "string" },
+  language: { type: "string" },
+  replace: { type: "boolean" },
+  into: { type: "string" },
+  level: { type: "string" },
+  mode: { type: "string" },
+  approve: { type: "boolean" },
+  pr: { type: "string" },
+  "pr-url": { type: "string" },
+  change: { type: "string" },
+  check: { type: "boolean" },
+  resume: { type: "string" },
+  eval: { type: "string" },
+  epic: { type: "string" },
+  "no-ai": { type: "boolean" },
+  "openspec-store": { type: "boolean" },
+  "no-drift": { type: "boolean" },
+  warnings: { type: "boolean" },
+  "no-rescan": { type: "boolean" },
+  refresh: { type: "string" },
+  export: { type: "string" },
+  result: { type: "string", multiple: true },
+  skip: { type: "boolean" },
+  note: { type: "string" },
+  for: { type: "string" },
+  with: { type: "string" },
+  inputs: { type: "string" },
+  "fill-only": { type: "boolean" },
+  platform: { type: "string" },
+  ref: { type: "string" },
+  task: { type: "string" },
+  latest: { type: "boolean" },
+  org: { type: "string" },
+  framework: { type: "string" },
+  csv: { type: "boolean" },
+  "no-write": { type: "boolean" },
+  junit: { type: "string" },
+  summary: { type: "string" },
+  "json-out": { type: "string" },
+  "warn-only": { type: "boolean" },
+  write: { type: "string" },
+  path: { type: "string" },
+  file: { type: "string" },
+  submodule: { type: "boolean" },
+  save: { type: "boolean" },
+  only: { type: "string" },
+  "verified-only": { type: "boolean" },
+  unverified: { type: "boolean" },
+  set: { type: "string", multiple: true },
+  find: { type: "string" },
+  drift: { type: "string", multiple: true },
+  journey: { type: "string" },
+  release: { type: "string" },
+  target: { type: "string" },
+  answer: { type: "string" },
+  lesson: { type: "string" },
+  step: { type: "string" },
+  agent: { type: "string", multiple: true },
+  runs: { type: "string" },
+  audience: { type: "string" },
+  value: { type: "string" },
+  bench: { type: "string" },
+  cache: { type: "string" },
+  batch: { type: "string" },
+  specs: { type: "boolean" },
+  estate: { type: "string" },
+  accept: { type: "boolean" },
+  // atticus repo add / repo describe (ADR 0128)
+  reject: { type: "boolean" },
+  cites: { type: "string" },
+  drafted: { type: "string" },
+  "no-description": { type: "boolean" },
+  component: { type: "string" },
+  tag: { type: "string" },
+  source: { type: "string" },
+  "from-figma": { type: "string" },
+  replaces: { type: "string" },
+  promote: { type: "string" },
+  prototype: { type: "string" },
+  off: { type: "boolean" },
+  surface: { type: "string" },
+  session: { type: "string" },
+  command: { type: "string" },
+  markdown: { type: "boolean" },
+  dir: { type: "string" },
+  commit: { type: "string" },
+  confirm: { type: "string" },
+  exclude: { type: "string" },
+  routed: { type: "string" },
+  // atticus map (ADR 0124 §4)
+  estimate: { type: "boolean" },
+  next: { type: "boolean" },
+  copy: { type: "boolean" },
+  facts: { type: "string" },
+  // ADR 0163: atticus repo-type note.
+  add: { type: "string" },
+  "org-wide": { type: "boolean" }
+};
+async function dispatchCommand(argv, io) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: OPTIONS,
+    strict: false
+  });
+  if (values.version) {
+    io.out(VERSION);
+    return 0;
+  }
+  const [group, command, arg] = positionals;
+  const refused = await checkFlags(argv, positionals, io);
+  if (refused !== void 0)
+    return refused;
+  if (group === "help" || values.help || !group) {
+    const { helpCommand } = await import("./chunk-TQYBXDVH.js");
+    return helpCommand(group === "help" ? positionals.slice(1) : positionals, HELP, io, {
+      all: values.all === true
+    });
+  }
+  if (group === "legacy") {
+    const { legacyHelp } = await import("./chunk-TQYBXDVH.js");
+    io.out(legacyHelp(HELP, { all: values.all === true }));
+    return 0;
+  }
+  if (group === "commands") {
+    const { AREAS, commandCatalog: commandCatalog2 } = await import("./chunk-O6ILVBYB.js");
+    const commands = commandCatalog2(HELP);
+    if (values.json === true)
+      io.out(JSON.stringify({ areas: AREAS, commands }, null, 2));
+    else
+      for (const a of AREAS) {
+        io.out(`${a.title}:`);
+        for (const c of commands.filter((x) => x.area === a.id))
+          io.out(`  atticus ${c.id}${c.runs === "local" ? "" : `  (${c.runs})`}`);
+      }
+    return 0;
+  }
+  if (group === "schema" && command === "export") {
+    await schemaExport(arg ?? "schema", io);
+    return 0;
+  }
+  if (group === "catalog" && command === "validate") {
+    if (!arg) {
+      io.err("catalog validate needs a folder, for example: atticus catalog validate catalog/generated");
+      return 2;
+    }
+    const s = await catalogValidate(arg, { fix: values.fix === true }, io);
+    return s.invalid + s.misplaced + s.notCanonical > 0 ? 1 : 0;
+  }
+  if (group === "catalog" && command === "diff") {
+    const b = positionals[3];
+    if (!arg || !b) {
+      io.err("catalog diff needs two folders, for example: atticus catalog diff catalog/generated /tmp/other");
+      return 2;
+    }
+    return catalogDiff(resolve(arg), resolve(b), values.json === true, io);
+  }
+  const root = resolve(typeof values.root === "string" ? values.root : process.cwd());
+  if (!runsNoAi(group, command))
+    await setUpAi();
+  if (group === "next")
+    return (await import("./chunk-DDAEAZEV.js")).nextCommand(root, { json: values.json === true, all: values.all === true, queue: values.queue === true }, io);
+  if (values.handoff === true && (await import("./chunk-KQDZXGNR.js")).isHandoffStep(group, command))
+    return (await import("./chunk-CZI2ACNT.js")).handoffStep(root, argv, io, dispatch);
+  const given = typeof values.by === "string" && values.by.trim() ? values.by : void 0;
+  const person = !given && RECORDS_A_PERSON.has(group) ? await gitUser(root) : void 0;
+  let warned = false;
+  const who = () => {
+    if (given)
+      return given;
+    if (person?.warning && !warned) {
+      io.err(person.warning);
+      warned = true;
+    }
+    return person?.handle ?? "someone";
+  };
+  const repoIds = typeof values.repos === "string" ? values.repos.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+  if (group === "change" && command === "needs" || group === "needs") {
+    const handled = await (await import("./chunk-XOVLGBKI.js")).needsCli(root, positionals, values, io, who);
+    if (handled !== void 0)
+      return handled;
+  }
+  if (group === "waiting") {
+    const given2 = Array.isArray(values.group) ? values.group[0] : values.group;
+    const g = given2 === void 0 ? "change" : String(given2);
+    if (g !== "change" && g !== "kind") {
+      io.err(`--group takes change or kind, not ${g}.`);
+      return 2;
+    }
+    const run = async (argv2) => {
+      const out = [];
+      const err = [];
+      const code = await main([...argv2, "--root", root], { out: (l) => out.push(l), err: (l) => err.push(l) }, { quiet: true });
+      return { code, out: out.join("\n"), err: err.join("\n") };
+    };
+    return (await import("./chunk-XZRON6IV.js")).waitingCli({
+      by: g,
+      ...typeof values.filter === "string" ? { filter: values.filter } : {},
+      json: values.json === true
+    }, io, run);
+  }
+  if (group === "runs") {
+    const m = await import("./chunk-SILY6ZEZ.js");
+    if (command === "show") {
+      const id = positionals[2];
+      if (!id) {
+        io.err("Usage: atticus runs show <run> [--json] (atticus runs lists them)");
+        return 2;
+      }
+      return m.runShowCli(root, id, { json: values.json === true }, io);
+    }
+    if (command !== void 0) {
+      io.err(`runs takes show <run>, or nothing to list them; not ${command}.`);
+      return 2;
+    }
+    const limit = num(values.limit);
+    return m.runsCli(root, {
+      ...typeof values.change === "string" ? { change: values.change } : {},
+      ...limit ? { limit } : {},
+      json: values.json === true
+    }, io);
+  }
+  if (group === "history") {
+    const m = await import("./chunk-HQMCHHY5.js");
+    const text = (v) => typeof v === "string" && v.trim() ? v : void 0;
+    if (command === "add") {
+      if (process.stdin.isTTY) {
+        io.err("history add reads the text from stdin; pipe the prompt or response into it (the plugin's hooks and VS Code do).");
+        return 2;
+      }
+      return m.historyAddCli(root, {
+        ...text(values.surface) ? { surface: text(values.surface) } : {},
+        ...text(values.kind) ? { kind: text(values.kind) } : {},
+        ...text(values.session) ? { session: text(values.session) } : {},
+        ...text(values.command) ? { command: text(values.command) } : {},
+        ...text(values.change) ? { change: text(values.change) } : {}
+      }, () => readAll(process.stdin), io);
+    }
+    if (command === "show") {
+      const id = positionals[2];
+      if (!id) {
+        io.err("Usage: atticus history show <id> [--json] (atticus history lists them)");
+        return 2;
+      }
+      return m.historyShowCli(root, id, { json: values.json === true }, io);
+    }
+    if (command === "on" || command === "off")
+      return m.historyOnOffCli(root, command === "on", io);
+    if (command !== void 0) {
+      io.err(`history takes show <id>, add, on or off, or nothing to list them; not ${command}.`);
+      return 2;
+    }
+    const limit = num(values.limit);
+    return m.historyCli(root, {
+      ...text(values.change) ? { change: text(values.change) } : {},
+      ...text(values.session) ? { session: text(values.session) } : {},
+      ...text(values.filter) ? { filter: text(values.filter) } : {},
+      ...limit ? { limit } : {},
+      json: values.json === true
+    }, io);
+  }
+  if (group === "change" && (command === "feature" || command === "architecture" || command === "small") || group === "plan" && command === "stories" || group === "bench" && command === "design") {
+    const handled = await stageCli(root, positionals, values, io);
+    if (handled !== void 0)
+      return handled;
+  }
+  if (group === "repo" && command === "rename") {
+    const { repoRename } = await import("./chunk-OR5VRULZ.js");
+    return repoRename(root, positionals[2], positionals[3], io);
+  }
+  if (group === "repo" && (command === "add" || command === "describe")) {
+    const m = await loadRepoCommands();
+    const str2 = (v) => typeof v === "string" ? v : void 0;
+    const pick = (...names) => Object.fromEntries(names.flatMap((n) => {
+      const v = str2(values[n]);
+      return v ? [[n, v]] : [];
+    }));
+    const first = (v) => Array.isArray(v) ? v[0] : str2(v);
+    if (command === "add")
+      return m.repoAdd(root, arg, {
+        ...pick("id", "type", "platform", "component", "description"),
+        ...first(values.owner) ? { owner: first(values.owner) } : {},
+        ...first(values.system) ? { system: first(values.system) } : {},
+        noDescription: values["no-description"] === true,
+        json: values.json === true
+      }, io);
+    return m.repoDescribe(root, arg, {
+      ...pick("description", "drafted", "cites"),
+      accept: values.accept === true,
+      reject: values.reject === true,
+      json: values.json === true
+    }, io);
+  }
+  if (group === "repo-type" && command === "note") {
+    const m = await loadRepoTypeCommands();
+    return m.repoTypeNote(root, arg, {
+      ...typeof values.add === "string" ? { add: values.add } : {},
+      org: values["org-wide"] === true
+    }, io);
+  }
+  if (group === "repo-type" && command === "rules") {
+    const m = await loadRepoTypeCommands();
+    return m.repoTypeRules(root, { write: values.save === true, json: values.json === true }, io);
+  }
+  if (group === "repo-type" && (command === "detect" || command === "new")) {
+    const m = await loadRepoTypeCommands();
+    const from = typeof values.from === "string" ? values.from : void 0;
+    if (command === "new")
+      return m.repoTypeNew(root, arg ?? "", { ...from ? { from } : {}, force: values.force === true }, io);
+    if (!arg) {
+      io.err("Usage: atticus repo-type detect <repo> [--json]");
+      return 2;
+    }
+    return m.repoTypeDetect(root, arg, { json: values.json === true }, io);
+  }
+  if (group === "scan" && command === "survey") {
+    const text = (v) => typeof v === "string" ? v : void 0;
+    if (!arg) {
+      io.err("Usage: atticus scan survey <repo> [--attempts 3] [--resume run] [--force] [--mode m]");
+      return 2;
+    }
+    const attempts = Number(text(values.attempts) ?? "3");
+    if (!Number.isInteger(attempts) || attempts < 1 || attempts > 10) {
+      io.err("--attempts is a whole number from 1 to 10.");
+      return 2;
+    }
+    try {
+      const { runtime } = await runtimeForCli(root, {
+        ...text(values.mode) ? { mode: text(values.mode) } : {}
+      });
+      return await scanSurvey(root, arg, {
+        attempts,
+        force: values.force === true,
+        ...text(values.resume) ? { resume: text(values.resume) } : {}
+      }, { runtime }, io);
+    } catch (e) {
+      if (e instanceof (await loadAi()).RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  }
+  if (group === "estate" && command === "fresh") {
+    const m = await import("./chunk-C75W7VXX.js");
+    return m.estateFresh(root, { json: values.json === true, all: values.all === true }, io);
+  }
+  if (group === "estate" && command === "shared") {
+    const m = await import("./chunk-5BJFMAQU.js");
+    const json2 = values.json === true;
+    const text = (v) => typeof v === "string" && v.trim() ? v : void 0;
+    if (arg === "import")
+      return m.sharedImport(root, positionals[3], {
+        ...text(values.team) ? { team: text(values.team) } : {},
+        ...text(values.system) ? { system: text(values.system) } : {},
+        ...text(values.name) ? { name: text(values.name) } : {},
+        ...text(values.commit) ? { commit: text(values.commit) } : {},
+        json: json2
+      }, io);
+    if (arg === "refresh")
+      return m.sharedRefresh(root, positionals[3], {
+        ...positionals[4] ? { dir: positionals[4] } : {},
+        ...text(values.commit) ? { commit: text(values.commit) } : {},
+        json: json2
+      }, io);
+    if (arg === "list" || arg === void 0)
+      return m.sharedList(root, { json: json2 }, io);
+    io.err("Usage: atticus join shared import|refresh|list (atticus help join)");
+    return 2;
+  }
+  if (group === "estate" && command === "contracts") {
+    const m = await import("./chunk-ZJQUIG3A.js");
+    return m.joinContracts(root, { json: values.json === true }, io);
+  }
+  if (group === "estate" && command === "measure") {
+    const m = await import("./chunk-JQX6BSE4.js");
+    return m.joinMeasure(root, arg, { json: values.json === true }, io);
+  }
+  if (group === "estate" && (command === "join" || command === "flow" || command === "lineage")) {
+    const m = await loadEstateCommands();
+    const field = positionals[3];
+    const depth = num(values.depth);
+    const o = { json: values.json === true, ...depth ? { depth } : {} };
+    if (command === "join")
+      return m.estateJoin(root, o, io);
+    if (!arg || command === "lineage" && !field) {
+      io.err(command === "flow" ? "Usage: atticus estate flow <flow-id> [--depth 5] [--json]" : "Usage: atticus estate lineage <flow-id> <field> [--depth 5] [--json]");
+      return 2;
+    }
+    return command === "flow" ? m.estateFlowCommand(root, arg, o, io) : m.estateLineage(root, arg, field, o, io);
+  }
+  if (group === "spec" && (command === "seed" || command === "accept")) {
+    const m = await import("./chunk-XF3DATVU.js");
+    if (!arg) {
+      io.err(command === "seed" ? "Usage: atticus spec seed <repo> [--json]" : "Usage: atticus spec accept <repo> [--by you]");
+      return 2;
+    }
+    return command === "seed" ? m.specSeed(root, arg, { json: values.json === true }, io) : m.specAccept(root, arg, { by: who() }, io);
+  }
+  if (group === "spec" && (command === "draft" || command === "check")) {
+    const text = (v) => typeof v === "string" ? v : void 0;
+    const m = await loadSpecCommands();
+    if (!arg) {
+      io.err(command === "draft" ? "Usage: atticus spec draft <repo> [--attempts 3] [--resume run] [--force] [--mode m]" : "Usage: atticus spec check <repo> [--json]");
+      return 2;
+    }
+    if (command === "check")
+      return m.specCheck(root, arg, { json: values.json === true }, io);
+    const attempts = Number(text(values.attempts) ?? "3");
+    if (!Number.isInteger(attempts) || attempts < 1 || attempts > 10) {
+      io.err("--attempts is a whole number from 1 to 10.");
+      return 2;
+    }
+    try {
+      const { runtime } = await runtimeForCli(root, {
+        ...text(values.mode) ? { mode: text(values.mode) } : {}
+      });
+      return await m.specDraft(root, arg, {
+        attempts,
+        force: values.force === true,
+        ...text(values.resume) ? { resume: text(values.resume) } : {}
+      }, { runtime }, io);
+    } catch (e) {
+      if (e instanceof (await loadAi()).RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  }
+  if (group === "map" && command === "render") {
+    const repo = positionals[2];
+    if (!repo) {
+      io.err("Usage: atticus map render <repo> [--json]");
+      return 2;
+    }
+    const { mapRenderCommand } = await import("./chunk-KLKENMWQ.js");
+    return mapRenderCommand(root, repo, { json: values.json === true }, io);
+  }
+  if (group === "map" && !command && values.all === true) {
+    const text = (v) => typeof v === "string" ? v : void 0;
+    const count = (flag) => {
+      const raw = text(values[flag]);
+      if (raw === void 0)
+        return void 0;
+      const n = Number(raw);
+      return Number.isInteger(n) && n > 0 ? n : NaN;
+    };
+    const numbers = {
+      maxParts: count("max-parts"),
+      budgetTokens: count("budget-tokens"),
+      idle: count("idle")
+    };
+    for (const [k, v] of Object.entries(numbers))
+      if (Number.isNaN(v)) {
+        io.err(`--${k === "maxParts" ? "max-parts" : k === "budgetTokens" ? "budget-tokens" : "idle"} is a whole number above 0.`);
+        return 2;
+      }
+    const asked = text(values.mode);
+    if (asked && !["model", "hand-off", "copilot"].includes(asked)) {
+      io.err("atticus map --all takes --mode model or --mode hand-off (Copilot Chat, a line pasted per part).");
+      return 2;
+    }
+    const { mapAllCommand } = await import("./chunk-WUE6HKIU.js");
+    const { copyToClipboard } = await import("./chunk-S5LSDXV4.js");
+    const typed = [];
+    const { createInterface } = await import("node:readline");
+    const rl = process.stdin.readable ? createInterface({ input: process.stdin, terminal: false }) : void 0;
+    rl?.on("line", (l) => typed.push(l));
+    const ac = new AbortController();
+    const onInt = () => {
+      if (ac.signal.aborted)
+        process.exit(130);
+      ac.abort();
+      io.err("Stopping after this step (Ctrl+C again stops at once)...");
+    };
+    process.on("SIGINT", onInt);
+    try {
+      return await mapAllCommand(root, {
+        ...text(values.repos) ? {
+          repos: text(values.repos).split(",").map((x) => x.trim()).filter(Boolean)
+        } : {},
+        stale: values.stale === true,
+        gaps: values.gaps === true,
+        dryRun: values["dry-run"] === true,
+        json: values.json === true,
+        ...asked ? { mode: asked === "model" ? "model" : "copilot" } : {},
+        ...numbers.maxParts ? { maxParts: numbers.maxParts } : {},
+        ...numbers.budgetTokens ? { budgetTokens: numbers.budgetTokens } : {},
+        ...numbers.idle ? { idleMinutes: numbers.idle } : {}
+      }, io, {
+        clipboard: copyToClipboard,
+        input: { take: () => typed.shift() },
+        signal: ac.signal,
+        makeRuntime: async () => (await runtimeForCli(root, { mode: "model", handoffValidate: async () => [] })).runtime
+      });
+    } catch (e) {
+      if (e instanceof (await loadAi()).RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    } finally {
+      process.off("SIGINT", onInt);
+      rl?.close();
+    }
+  }
+  if (group === "map") {
+    const repo = command;
+    if (!repo) {
+      io.err("Usage: atticus map <repo> [--estimate | --gaps [--part n]] [--handoff | --copy [--answer <file>] | --mode m] [--next] [--max-tokens n] [--force], or atticus map --all [--stale | --gaps] [--repos a,b] [--dry-run] [--max-tokens n]");
+      return 2;
+    }
+    const text = (v) => typeof v === "string" ? v : void 0;
+    if (values.spent !== void 0 || values.sessions !== void 0) {
+      const { mapSpent } = await import("./chunk-OHXTB6CO.js");
+      return mapSpent(root, repo, {
+        ...text(values.spent) !== void 0 ? { spent: text(values.spent) } : {},
+        ...text(values.sessions) !== void 0 ? { sessions: text(values.sessions) } : {},
+        ...text(values.part) !== void 0 ? { part: text(values.part) } : {},
+        ...text(values.by) ? { by: text(values.by) } : {}
+      }, io);
+    }
+    const { mapCommand } = await import("./chunk-D7MWYJZF.js");
+    const o = {
+      ...text(values.dir) ? { dir: resolve(text(values.dir)) } : {},
+      ...text(values.commit) ? { commit: text(values.commit) } : {},
+      ...text(values.resume) ? { resume: text(values.resume) } : {},
+      ...text(values.answer) !== void 0 ? { answer: text(values.answer) } : {},
+      estimate: values.estimate === true,
+      gaps: values.gaps === true,
+      // ADR 0161: with --gaps, the rest of one part of the read plan.
+      ...values.gaps === true && Number.isInteger(Number(text(values.part))) && Number(text(values.part)) > 0 ? { part: Number(text(values.part)) } : {},
+      next: values.next === true,
+      force: values.force === true,
+      copy: values.copy === true,
+      json: values.json === true
+    };
+    if (o.estimate || o.gaps)
+      return mapCommand(root, repo, o, io);
+    try {
+      const { runtime } = await runtimeForCli(root, {
+        ...o.copy ? { mode: "hand-off" } : text(values.mode) ? { mode: text(values.mode) } : {},
+        handoffValidate: async () => []
+      });
+      return await mapCommand(root, repo, o, io, { runtime });
+    } catch (e) {
+      if (e instanceof (await loadAi()).RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  }
+  if (group === "verify") {
+    const v = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        ...OPTIONS,
+        write: { type: "boolean" },
+        verbose: { type: "boolean" },
+        skipped: { type: "boolean" },
+        size: { type: "string" },
+        seed: { type: "string" },
+        answers: { type: "string" },
+        right: { type: "string" },
+        wrong: { type: "string" },
+        unsure: { type: "string" },
+        report: { type: "boolean" }
+      },
+      strict: false
+    });
+    const repo = v.positionals[1];
+    const text = (x) => typeof x === "string" ? x : void 0;
+    if (repo === "audit" && (v.positionals[2] || v.values.report === true)) {
+      const { auditCommand } = await import("./chunk-JUQHYTXN.js");
+      const ids = (x) => text(x)?.split(",").map((y) => y.trim()).filter(Boolean);
+      const size = Number(text(v.values.size));
+      const interactive = process.stdin.isTTY && v.values.json !== true;
+      let rl;
+      const ask = interactive ? async (q) => {
+        const { createInterface } = await import("node:readline/promises");
+        rl ??= createInterface({ input: process.stdin, output: process.stdout });
+        return rl.question(`${q} `);
+      } : void 0;
+      try {
+        return await auditCommand(text(v.values.root) ? resolve(text(v.values.root)) : root, v.positionals[2], {
+          by: who(),
+          ...Number.isFinite(size) && size > 0 ? { size } : {},
+          ...text(v.values.seed) ? { seed: text(v.values.seed) } : {},
+          ...text(v.values.dir) ? { dir: resolve(text(v.values.dir)) } : {},
+          ...text(v.values.answers) ? { answers: text(v.values.answers) } : {},
+          ...ids(v.values.right) ? { right: ids(v.values.right) } : {},
+          ...ids(v.values.wrong) ? { wrong: ids(v.values.wrong) } : {},
+          ...ids(v.values.unsure) ? { unsure: ids(v.values.unsure) } : {},
+          report: v.values.report === true,
+          json: v.values.json === true,
+          ...ask ? { ask } : {}
+        }, io);
+      } finally {
+        rl?.close();
+      }
+    }
+    if (!repo && v.values.all === true) {
+      const { verifyAllCommand } = await import("./chunk-55TBYJF2.js");
+      return verifyAllCommand(text(v.values.root) ? resolve(text(v.values.root)) : root, {
+        ...v.values.write === true ? { write: true } : {},
+        ...v.values.verbose === true ? { verbose: true } : {}
+      }, io);
+    }
+    if (!repo) {
+      io.err("Usage: atticus verify <repo> [--write [--verbose]] [--dir path] [--commit sha] [--routed a,b] [--skipped] [--json], or atticus verify --all [--write]");
+      return 2;
+    }
+    const { verifyCommand } = await import("./chunk-55TBYJF2.js");
+    return verifyCommand(
+      // The first reading took --write's next word as its value, so a --root right after it
+      // was lost; this reading has --write as a switch.
+      text(v.values.root) ? resolve(text(v.values.root)) : root,
+      repo,
+      {
+        ...text(v.values.dir) ? { dir: resolve(text(v.values.dir)) } : {},
+        ...text(v.values.commit) ? { commit: text(v.values.commit) } : {},
+        ...text(v.values.routed) ? {
+          routed: text(v.values.routed).split(",").map((x) => x.trim()).filter(Boolean)
+        } : {},
+        write: v.values.write === true,
+        verbose: v.values.verbose === true,
+        json: v.values.json === true,
+        ...v.values.skipped === true ? { skipped: true } : {}
+      },
+      io
+    );
+  }
+  if (group === "scan" && command === "verify") {
+    const text = (v) => typeof v === "string" ? v : void 0;
+    if (!arg) {
+      io.err("Usage: atticus scan verify <repo> [--attempts 3] [--resume run] [--mode m] [--json] | --accept");
+      return 2;
+    }
+    const m = await loadScanVerifyCommands();
+    if (values.accept === true) {
+      const by = given ?? (await gitUser(root)).handle ?? "someone";
+      return m.scanVerifyAccept(root, arg, { by }, io);
+    }
+    const attempts = Number(text(values.attempts) ?? "3");
+    if (!Number.isInteger(attempts) || attempts < 1 || attempts > 10) {
+      io.err("--attempts is a whole number from 1 to 10.");
+      return 2;
+    }
+    try {
+      const { runtime } = await runtimeForCli(root, {
+        ...text(values.mode) ? { mode: text(values.mode) } : {}
+      });
+      return await m.scanVerify(root, arg, {
+        attempts,
+        json: values.json === true,
+        ...text(values.resume) ? { resume: text(values.resume) } : {}
+      }, { runtime }, io);
+    } catch (e) {
+      if (e instanceof (await loadAi()).RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  }
+  if (group === "scan" && command === "review") {
+    const text = (v) => typeof v === "string" ? v : void 0;
+    if (!arg) {
+      io.err("Usage: atticus scan review <repo> [--gaps] [--name n] [--attempts 3] [--resume run] [--mode m]");
+      return 2;
+    }
+    const attempts = Number(text(values.attempts) ?? "3");
+    if (!Number.isInteger(attempts) || attempts < 1 || attempts > 10) {
+      io.err("--attempts is a whole number from 1 to 10.");
+      return 2;
+    }
+    try {
+      const { runtime } = await runtimeForCli(root, {
+        ...text(values.mode) ? { mode: text(values.mode) } : {}
+      });
+      return await scanReview(root, arg, {
+        gapsOnly: values.gaps === true,
+        attempts,
+        ...text(values.name) ? { name: text(values.name) } : {},
+        ...text(values.resume) ? { resume: text(values.resume) } : {}
+      }, { runtime }, io);
+    } catch (e) {
+      if (e instanceof (await loadAi()).RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  }
+  if (group === "scan")
+    return scanCommand(root, {
+      ...repoIds ? { repos: repoIds } : {},
+      full: values.full === true,
+      dryRun: values["dry-run"] === true,
+      json: values.json === true,
+      noDrift: values["no-drift"] === true,
+      warnings: values.warnings === true,
+      ...typeof values.ref === "string" && values.ref.trim() ? { ref: values.ref.trim() } : {}
+    }, io);
+  if (group === "cites") {
+    const given2 = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+    const [repo, path, file] = [given2(values.repo), given2(values.path), given2(values.file)];
+    return (await import("./chunk-OJN7WME4.js")).citesCli(root, {
+      ...repo ? { repo } : {},
+      ...path ? { path } : {},
+      ...file ? { file: resolve(file) } : {},
+      json: values.json === true
+    }, io);
+  }
+  if (group === "watch")
+    return (await import("./chunk-4YWRU7JK.js")).watchCommand(root, command, { off: values.off === true, json: values.json === true }, io);
+  if (group === "setup" && !command)
+    return setupCommand(root, { json: values.json === true }, io);
+  if (group === "doctor" && values.counts === true)
+    return (await import("./chunk-SNHOLLGN.js")).doctorCountsCommand(root, { json: values.json === true }, io);
+  if (group === "doctor")
+    return doctorCommand(root, { json: values.json === true }, io);
+  if (group === "probe") {
+    const { probeCommand, probeAnswerCommand } = await import("./chunk-NX6QEEOA.js");
+    const max = typeof values["max-tokens"] === "string" ? Number(values["max-tokens"]) : void 0;
+    const json2 = values.json === true;
+    if (command === "answer")
+      return probeAnswerCommand(root, positionals[2], { pasted: values.pasted === true, ...max !== void 0 ? { maxTokens: max } : {}, json: json2 }, io);
+    if (command) {
+      io.err("Usage: atticus probe [--assistant id] [--max-tokens n] [--json] | atticus probe answer <code|none> [--pasted] [--max-tokens n] [--json]");
+      return 2;
+    }
+    return probeCommand(root, {
+      ...typeof values.assistant === "string" ? { assistant: values.assistant } : {},
+      ...max !== void 0 ? { maxTokens: max } : {},
+      json: json2
+    }, io);
+  }
+  if (group === "upgrade")
+    return upgradeCommand(root, {
+      check: values.check === true,
+      dryRun: values["dry-run"] === true,
+      ...values.check === true || values["dry-run"] === true ? {} : { by: who() },
+      json: values.json === true,
+      ...values["openspec-store"] === true ? { openspecStore: true } : {}
+    }, io);
+  if (group === "support" && command === "bundle")
+    return supportBundleCommand(root, {
+      ...typeof values.out === "string" && values.out ? { out: values.out } : {},
+      json: values.json === true
+    }, io);
+  if (group === "baseline")
+    return baselineCommand(root, {
+      by: who(),
+      ...typeof values.note === "string" && values.note ? { note: values.note } : {},
+      ...typeof values.site === "string" && values.site ? { site: values.site } : {}
+    }, io);
+  if (group === "digest")
+    return digestCommand(root, {
+      as: typeof values.as === "string" && values.as ? values.as : who(),
+      ...typeof values.channel === "string" && values.channel ? { channel: values.channel } : {},
+      send: values.send === true,
+      json: values.json === true
+    }, io);
+  if (group === "guide")
+    return guideCommand(root, command, { json: values.json === true }, io);
+  if (group === "site" && command === "build")
+    return siteBuildCommand(root, positionals[2], { ...typeof values.title === "string" && values.title ? { title: values.title } : {} }, io);
+  if (group === "ask") {
+    if (!command) {
+      io.err('ask needs a question, for example: atticus ask "who calls ledger-api?"');
+      return 2;
+    }
+    return askCommand(root, command, { json: values.json === true }, io);
+  }
+  if (group === "context") {
+    const m = await import("./chunk-GWSWS264.js");
+    const target = positionals[2];
+    const csv = (v) => typeof v === "string" ? v.split(",").map((k) => k.trim()).filter(Boolean) : void 0;
+    if (command === "tools")
+      return m.contextTools({ json: values.json === true }, io);
+    if (command === "show" || command === "walk") {
+      if (!target) {
+        io.err(`Usage: atticus context ${command} <id> (an id the index has; atticus query "<words>" --search finds one)`);
+        return 2;
+      }
+      if (command === "show")
+        return m.contextShow(root, target, io);
+      return m.contextWalk(root, target, {
+        ...num(values.hops) ? { hops: num(values.hops) } : {},
+        ...csv(values.kind) ? { kinds: csv(values.kind) } : {},
+        ...num(values.limit) ? { limit: num(values.limit) } : {}
+      }, io);
+    }
+    if (command === "code") {
+      const repo = typeof values.repo === "string" ? values.repo : void 0;
+      const path = typeof values.path === "string" ? values.path : void 0;
+      if (!target && !(repo && path && num(values.line))) {
+        io.err("Usage: atticus context code <id>, or --repo <repo> --path <path> --line <n> (a line a fact cites)");
+        return 2;
+      }
+      const around = typeof values.around === "string" ? Number(values.around) : void 0;
+      return m.contextCode(root, {
+        ...target ? { id: target } : {},
+        ...repo ? { repo } : {},
+        ...path ? { path } : {},
+        ...num(values.line) ? { line: num(values.line) } : {},
+        ...around !== void 0 && Number.isInteger(around) ? { around } : {}
+      }, io);
+    }
+    const repoOpt = typeof values.repo === "string" && values.repo ? values.repo : void 0;
+    if (command === "grep") {
+      if (!target) {
+        io.err('Usage: atticus context grep "<pattern>" [--regex] [--ignore-case] [--repo r] [--paths glob] [--limit n]');
+        return 2;
+      }
+      return m.contextGrep(root, target, {
+        ...values.regex === true ? { regex: true } : {},
+        ...values["ignore-case"] === true ? { ignoreCase: true } : {},
+        ...repoOpt ? { repo: repoOpt } : {},
+        ...typeof values.paths === "string" && values.paths ? { paths: values.paths } : {},
+        ...num(values.limit) ? { limit: num(values.limit) } : {}
+      }, io);
+    }
+    if (command === "files") {
+      if (!target) {
+        io.err('Usage: atticus context files "<glob>" [--repo r] [--limit n], e.g. "src/**/*.java"');
+        return 2;
+      }
+      return m.contextFiles(root, target, {
+        ...repoOpt ? { repo: repoOpt } : {},
+        ...num(values.limit) ? { limit: num(values.limit) } : {}
+      }, io);
+    }
+    if (command === "outline") {
+      const file = positionals[3];
+      if (!target || !file) {
+        io.err("Usage: atticus context outline <repo> <path> (the file's path in the repo)");
+        return 2;
+      }
+      return m.contextOutline(root, target, file, io);
+    }
+    if (command === "call") {
+      if (!target) {
+        io.err("Usage: atticus context call <tool> --input <json> [--run <run>] (atticus context tools lists the tools)");
+        return 2;
+      }
+      return m.contextCall(root, target, {
+        ...typeof values.input === "string" ? { input: values.input } : {},
+        ...typeof values.run === "string" ? { run: values.run } : {},
+        ...num(values.round) ? { round: num(values.round) } : {},
+        json: values.json === true
+      }, io);
+    }
+    if (command === "similar") {
+      if (!target) {
+        io.err("Usage: atticus context similar <id> [--kind k,k] [--limit n]");
+        return 2;
+      }
+      return m.contextSimilar(root, target, {
+        ...csv(values.kind) ? { kinds: csv(values.kind) } : {},
+        ...num(values.limit) ? { limit: num(values.limit) } : {}
+      }, io);
+    }
+    io.err(`context takes show, walk, code, grep, files, outline, similar, tools or call; not ${command ?? "nothing"}.`);
+    return 2;
+  }
+  if (group === "query") {
+    if (!command) {
+      io.err('query needs a query, for example: atticus query "kind:interface via:gateway"');
+      return 2;
+    }
+    if (values.search === true)
+      return searchCommand(root, command, {
+        json: values.json === true,
+        ...num(values.limit) ? { limit: num(values.limit) } : {},
+        ...typeof values.kind === "string" ? { kind: values.kind } : {},
+        ...typeof values.by === "string" ? { by: values.by } : {}
+      }, io);
+    return queryCommand(root, command, { json: values.json === true, ...num(values.limit) ? { limit: num(values.limit) } : {} }, io);
+  }
+  if (group === "impact") {
+    if (!command) {
+      io.err("impact needs a record id, for example: atticus impact ledger-db.entry");
+      return 2;
+    }
+    return impactCommand(root, command, { json: values.json === true, ...num(values.depth) ? { depth: num(values.depth) } : {} }, io);
+  }
+  if (group === "index" && command === "rebuild")
+    return indexRebuild(root, io);
+  if (group === "index" && command === "embed")
+    return (await import("./chunk-LZWVK4YY.js")).indexEmbed(root, io);
+  if (group === "alias") {
+    const target = positionals[2];
+    if (!command || !target) {
+      io.err('alias needs a name and an id, for example: atticus alias "Ledger Platform" ledger-api');
+      return 2;
+    }
+    return aliasCommand(root, command, target, {
+      by: who(),
+      ...typeof values.reason === "string" ? { reason: values.reason } : {}
+    }, io);
+  }
+  const str = (v) => typeof v === "string" ? v : void 0;
+  const json = values.json === true;
+  if (group === "initiative") {
+    const by = command === "status" ? void 0 : who();
+    const systems = Array.isArray(values.system) ? values.system : [];
+    if (command === "new")
+      return initiativeNew(root, {
+        ...arg ? { title: positionals.slice(2).join(" ") } : {},
+        ...str(values.journey) ? { journey: str(values.journey) } : {},
+        ...by ? { by } : {},
+        ...str(values.id) ? { id: str(values.id) } : {},
+        ...str(values.release) ? { release: str(values.release) } : {},
+        ...str(values.epic) ? { epic: str(values.epic) } : {},
+        json
+      }, io);
+    if (command === "plan")
+      return initiativePlan(root, arg, {
+        ...str(values.target) ? { target: str(values.target) } : {},
+        ...str(values.release) ? { release: str(values.release) } : {},
+        ...systems.length ? { systems } : {},
+        ...by ? { by } : {},
+        dryRun: values["dry-run"] === true,
+        json
+      }, io);
+    if (command === "status")
+      return initiativeStatus(root, arg, { json }, io);
+    if (command === "request")
+      return requestFromTeam(root, arg, positionals[3], { ...by ? { by } : {}, ...systems.length ? { systems } : {}, json }, io);
+    if (command === "commit")
+      return initiativeCommitment(root, arg, positionals[3], { ...by ? { by } : {} }, io);
+  }
+  if (group === "learn") {
+    if (!command || command === "list")
+      return learnList(root, { json }, io);
+    if (command === "start")
+      return learnStart(root, arg, { json }, io);
+    if (command === "check")
+      return learnCheck(root, {
+        ...str(values.answer) ? { answer: str(values.answer) } : {},
+        ...str(values.lesson) ? { lesson: str(values.lesson) } : {},
+        ...str(values.step) ? { step: str(values.step) } : {},
+        json
+      }, io);
+  }
+  if (group === "sandbox" && command === "create")
+    return sandboxCreate(arg ? resolve(arg) : void 0, { json }, io);
+  if (group === "explain")
+    return explainCommand(root, positionals.slice(1).join(" ") || void 0, { json }, io);
+  if (group === "eval" && command === "run")
+    return evalRun(root, {
+      ...Array.isArray(values.agent) ? { agent: values.agent } : {},
+      ...str(values.mode) ? { mode: str(values.mode) } : {},
+      ...num(values.runs) ? { runs: num(values.runs) } : {},
+      json
+    }, io);
+  if (group === "eval" && command === "report")
+    return evalReport(root, { json }, io);
+  if (group === "bench" && (command === "facts" || command === "stories")) {
+    const m = await import("./chunk-GG6HIU74.js");
+    return m.benchScoreCli(command, arg, values, io, root);
+  }
+  if (group === "bench" && (command === "fetch" || command === "run" || command === "survey" || command === "verify")) {
+    const b = {
+      ...str(values.bench) ? { bench: str(values.bench) } : {},
+      ...str(values.cache) ? { cache: str(values.cache) } : {},
+      ...str(values.repo) ? { repo: str(values.repo) } : {},
+      ...num(values.batch) ? { batch: num(values.batch) } : {},
+      ...str(values.estate) ? { estate: str(values.estate) } : {},
+      json
+    };
+    if (command === "survey")
+      return benchSurvey({ ...b, ...str(values.mode) ? { mode: str(values.mode) } : {} }, io);
+    if (command === "verify")
+      return benchVerify({ ...b, ...str(values.mode) ? { mode: str(values.mode) } : {} }, io);
+    return command === "fetch" ? benchFetch(b, io) : benchRun({ ...b, ...values.specs === true ? { specs: true } : {} }, io);
+  }
+  if (group === "mcp") {
+    const run = async (argv2) => {
+      const out = [];
+      const err = [];
+      const code = await main([...argv2, "--root", root], { out: (l) => out.push(l), err: (l) => err.push(l) }, { quiet: true });
+      return { code, out: out.join("\n"), err: err.join("\n") };
+    };
+    const { serveMcp } = await import("./chunk-EADP3PEN.js");
+    await serveMcp(process.stdin, process.stdout, run, VERSION);
+    return 0;
+  }
+  if (group === "ui") {
+    if (values.embed !== void 0 && values.embed !== "vscode") {
+      io.err(`--embed takes vscode (the app in a VS Code panel), not ${values.embed}.`);
+      return 2;
+    }
+    const parent = values.parent === void 0 ? void 0 : Number(values.parent);
+    if (parent !== void 0 && !(Number.isInteger(parent) && parent > 0)) {
+      io.err(`--parent takes a process id, not ${String(values.parent)}.`);
+      return 2;
+    }
+    return uiCommand(root, {
+      // --port 0 asks for any free port.
+      ...values.port === "0" ? { port: 0 } : num(values.port) ? { port: num(values.port) } : {},
+      open: values.open === true,
+      showToken: values["show-token"] === true,
+      ...values.full === true ? { full: true } : {},
+      ...values.embed === "vscode" ? { embed: "vscode" } : {},
+      ...parent !== void 0 ? { parent } : {},
+      version: VERSION,
+      ...given ? { user: given } : {}
+    }, io);
+  }
+  if (group === "secret") {
+    const { secretCommand } = await import("./chunk-SG5KY4VB.js");
+    return secretCommand(positionals.slice(1), io);
+  }
+  if (group === "conformance") {
+    if (!command) {
+      io.err("conformance needs a folder or file to check, for example: atticus conformance catalog --kind catalog");
+      return 2;
+    }
+    return conformanceCommand(command, {
+      ...str(values.kind) ? { kind: str(values.kind) } : {},
+      ...str(values.executor) ? { executor: str(values.executor) } : {},
+      ...str(values.fixture) ? { fixture: str(values.fixture) } : {},
+      json
+    }, io);
+  }
+  if (group === "defences" && command === "scan")
+    return defencesScan(root, arg ? resolve(arg) : void 0, { json, all: values.all === true }, io);
+  if (group === "tests" && command === "generate")
+    return testsGenerate(root, arg, positionals[3], {
+      ...str(values.framework) ? { framework: str(values.framework) } : {},
+      force: values.force === true,
+      check: values.check === true,
+      ...str(values.mode) ? { mode: str(values.mode) } : {},
+      ...str(values.resume) ? { resume: str(values.resume) } : {},
+      json
+    }, io);
+  if (group === "trace")
+    return traceCommand(root, command, { json, csv: values.csv === true, write: values["no-write"] !== true }, io);
+  if (group === "release") {
+    if (command === "plan")
+      return releasePlanCommand(root, arg, { json }, io);
+    if (command === "forecast")
+      return releaseForecastCommand(root, arg, { json }, io);
+    if (command === "evidence")
+      return releaseEvidenceCommand(root, arg, { ...str(values.out) ? { out: str(values.out) } : {}, json }, io);
+    if (command === "notes")
+      return releaseNotesCommand(root, arg, { ...str(values.audience) ? { audience: str(values.audience) } : {}, json }, io);
+    if (command === "security")
+      return releaseSecurityCommand(root, arg, { json }, io);
+  }
+  if (group === "outcome" && (!command || command === "list"))
+    return outcomeList(root, { ...str(values.change) ? { change: str(values.change) } : {}, json }, io);
+  if (group === "outcome" && command === "record")
+    return outcomeRecord(root, arg, positionals[3], {
+      ...str(values.value) ? { value: str(values.value) } : {},
+      by: who(),
+      ...str(values.note) ? { note: str(values.note) } : {},
+      json
+    }, io);
+  if (group === "ci" && command === "drift")
+    return ciDrift(resolve(arg ?? "."), {
+      ...str(values.catalog) ? { catalog: resolve(str(values.catalog)) } : {},
+      json: str(values["json-out"]) ?? json,
+      ...str(values.junit) ? { junit: str(values.junit) } : {},
+      ...str(values.summary) ? { summary: str(values.summary) } : {},
+      warnOnly: values["warn-only"] === true,
+      ...str(values.repo) ? { repo: str(values.repo) } : {}
+    }, io);
+  if (group === "ci" && command === "snippet")
+    return ciSnippet(arg, io, { ...str(values.write) ? { write: str(values.write) } : {} });
+  if (group === "ci" && command === "archive-gate")
+    return ciArchiveGate(root, arg, { ...Array.isArray(values.drift) ? { drift: values.drift } : {}, json }, io);
+  if (group === "glossary") {
+    const by = ["define", "link", "alias"].includes(command ?? "") ? who() : void 0;
+    if (command === "list")
+      return glossaryList(root, { json }, io);
+    if (command === "scan")
+      return glossaryScan(root, { ...str(values.mode) ? { mode: str(values.mode) } : {}, json }, io);
+    const ownerOne = Array.isArray(values.owner) ? values.owner[0] : str(values.owner);
+    if (command === "define")
+      return glossaryDefine(root, arg, positionals.slice(3).join(" ") || void 0, { ...by ? { by } : {}, ...ownerOne ? { owner: ownerOne } : {} }, io);
+    if (command === "link")
+      return glossaryLink(root, arg, positionals[3], { ...by ? { by } : {} }, io);
+    if (command === "alias")
+      return glossaryAlias(root, arg, positionals.slice(3), { ...by ? { by } : {} }, io);
+  }
+  if (group === "init") {
+    const owner = Array.isArray(values.owner) ? values.owner[0] : str(values.owner);
+    const dir = resolve(command ?? ".");
+    const code = await initCommand(dir, {
+      ...command ? { name: basename(dir) } : {},
+      ...str(values.platform) ? { platform: str(values.platform) } : {},
+      ...str(values.from) ? { packFrom: resolve(str(values.from)) } : {},
+      ...owner ? { owner } : {},
+      ...values["openspec-store"] === true ? { openspecStore: true } : {},
+      json
+    }, io);
+    return code;
+  }
+  if (group === "adopt")
+    return adoptCommand(resolve(command ?? "."), {
+      json,
+      ...str(values.platform) ? { platform: str(values.platform) } : {},
+      ...str(values.name) ? { name: str(values.name) } : {}
+    }, io);
+  if (group === "unadopt")
+    return unadoptCommand(resolve(command ?? "."), io);
+  if (group === "repos" && command === "discover")
+    return reposDiscoverCommand(root, {
+      ...arg ? { from: resolve(arg) } : {},
+      ...str(values.org) ? { org: str(values.org) } : {},
+      ...str(values.platform) ? { platform: str(values.platform) } : {},
+      dryRun: values["dry-run"] === true,
+      json
+    }, io);
+  if (group === "absorb") {
+    if (str(values.refresh))
+      return absorbRefreshCommand(root, str(values.refresh), { json }, io);
+    if (command === "accept")
+      return absorbAcceptCommand(root, arg ?? "", { replace: values.replace === true, dryRun: values["dry-run"] === true, json }, io);
+    if (!command) {
+      io.err("absorb needs a git URL or a folder, for example: atticus absorb ../payments-metarepo --id payments");
+      return 2;
+    }
+    return absorbCommand(root, command, {
+      ...str(values.id) ? { id: str(values.id) } : {},
+      ...str(values.mode) ? { mode: str(values.mode) } : {},
+      ...str(values.ref) ? { ref: str(values.ref) } : {},
+      json,
+      dryRun: values["dry-run"] === true
+    }, io);
+  }
+  const approver = values.approve === true ? who() : void 0;
+  const dryRun = values["dry-run"] === true;
+  if (group === "plan") {
+    if (!arg) {
+      io.err(`plan ${command ?? ""} needs a change id, for example: atticus plan stories add-transfer-limit`.replace("  ", " "));
+      return 2;
+    }
+    if (command === "stories")
+      return planStories(root, arg, {
+        force: values.force === true,
+        draft: values.draft === true,
+        ...str(values.resume) ? { resume: str(values.resume) } : {},
+        ...str(values.mode) ? { mode: str(values.mode) } : {},
+        json
+      }, io);
+    if (command === "snow")
+      return snowDraft(root, arg, { force: values.force === true, json }, io);
+    if (command === "bar")
+      return storyBarCommand(root, arg, { ...str(values.eval) ? { eval: str(values.eval) } : {}, json }, io);
+    if (command === "submit")
+      return snowSubmit(root, arg, { ...approver ? { approve: approver } : {}, dryRun, json }, io);
+  }
+  if (group === "ado" && command === "sync") {
+    if (!arg) {
+      io.err("ado sync needs a change id");
+      return 2;
+    }
+    return adoSync(root, arg, {
+      ...approver ? { approve: approver } : {},
+      dryRun,
+      ...str(values.epic) ? { epic: str(values.epic) } : {},
+      json
+    }, io);
+  }
+  if (group === "templates" && command === "draft")
+    return templatesDraft(root, {
+      ...str(values.mode) ? { mode: str(values.mode) } : {},
+      json,
+      noAi: values["no-ai"] === true
+    }, io);
+  if (group === "executors" && command === "check")
+    return executorsCheck(root, { json }, io);
+  if (group === "todo") {
+    if (!command || command === "list")
+      return todoList(root, {
+        json,
+        ...str(values.change) ? { change: str(values.change) } : {},
+        all: values.all === true
+      }, io);
+    if (!arg) {
+      io.err(`todo ${command} needs a step id; see atticus todo`);
+      return 2;
+    }
+    if (command === "show")
+      return todoShow(root, arg, { ...str(values.export) ? { export: str(values.export) } : {} }, io);
+    if (command === "done") {
+      const results = Array.isArray(values.result) ? values.result : [];
+      return todoDone(root, arg, {
+        result: results,
+        by: who(),
+        skip: values.skip === true,
+        ...str(values.note) ? { note: str(values.note) } : {}
+      }, io);
+    }
+    if (command === "run")
+      return todoRun(root, arg, {
+        ...str(values.with) ? { with: str(values.with) } : {},
+        ...approver ? { approve: approver } : {},
+        ...str(values.inputs) ? { inputs: str(values.inputs) } : {},
+        fillOnly: values["fill-only"] === true
+      }, io);
+  }
+  if (group === "task" && command === "context")
+    return (await import("./chunk-OFWYZH6B.js")).taskContextCli(root, arg, positionals[3], { json, markdown: values.markdown === true }, io);
+  if (group === "change" && command === "attach")
+    return (await import("./chunk-OFWYZH6B.js")).changeAttachCli(root, arg, positionals.slice(3), {
+      by: who(),
+      json,
+      ...typeof values.replaces === "string" && values.replaces.trim() ? { replaces: values.replaces.trim() } : {},
+      ...typeof values.promote === "string" && values.promote.trim() ? { promote: values.promote.trim() } : {},
+      ...typeof values.like === "string" && values.like.trim() ? { like: values.like.trim() } : {},
+      ...typeof values.prototype === "string" && values.prototype.trim() ? { prototype: values.prototype.trim() } : {}
+    }, io);
+  if (group === "task" && command === "run")
+    return taskRun(root, arg, positionals[3], {
+      ...str(values.level) ? { level: str(values.level) } : {},
+      ...str(values.mode) ? { mode: str(values.mode) } : {},
+      by: who(),
+      approve: values.approve === true,
+      json
+    }, io);
+  if (group === "spec" && command === "hand-down")
+    return specHandDown(root, arg, positionals[3], { force: values.force === true, json }, io);
+  if (group === "spec" && command === "hand-up")
+    return specHandUp(root, arg, positionals[3], {
+      by: who(),
+      ...num(values.pr) ? { pr: num(values.pr) } : {},
+      ...str(values["pr-url"]) ? { prUrl: str(values["pr-url"]) } : {},
+      json
+    }, io);
+  if (group === "drift")
+    return driftCommand(root, command, { json }, io);
+  if (group === "assistant-files" && existsSync(join(root, ".atticus", "adopted.yaml")))
+    return zeroInstallCommand(root, { check: values.check === true, force: values.force === true }, io);
+  if (group === "assistant-files")
+    return assistantFiles(root, {
+      ...str(values.repo) ? { repo: str(values.repo) } : {},
+      ...str(values.change) ? { change: str(values.change) } : {},
+      force: values.force === true,
+      check: values.check === true,
+      json
+    }, io);
+  if (group === "catalog" && command === "migrate")
+    return catalogMigrate(root, io, { dryRun: values["dry-run"] === true });
+  if (group === "feature") {
+    const rest = positionals.slice(3);
+    const writes = ["name", "tag", "merge", "split", "link"].includes(command ?? "");
+    const by = writes ? who() : void 0;
+    const firstOwner = Array.isArray(values.owner) ? values.owner[0] : str(values.owner);
+    if (command === "list")
+      return featureList(root, { json }, io);
+    if (command === "suggest-links")
+      return featureSuggestLinks(root, { json }, io);
+    if (command === "suggest-names") {
+      try {
+        const { runtime } = await runtimeForCli(root, {
+          ...str(values.mode) ? { mode: str(values.mode) } : {}
+        });
+        return await featureSuggestNames(root, { runtime, json }, io);
+      } catch (e) {
+        if (e instanceof (await loadAi()).RuntimeConfigError) {
+          io.err(e.message);
+          return 2;
+        }
+        throw e;
+      }
+    }
+    if (!arg) {
+      io.err(`feature ${command ?? ""} needs a feature id, for example: atticus feature show feature.transfers`);
+      return 2;
+    }
+    if (command === "show")
+      return featureShow(root, arg, { json }, io);
+    if (command === "spec")
+      return featureSpec(root, arg, io);
+    if (command === "name") {
+      if (!rest[0]) {
+        io.err('feature name needs a name, for example: atticus feature name feature.transfers "Transfer money"');
+        return 2;
+      }
+      return featureName(root, arg, rest.join(" "), {
+        ...by ? { by } : {},
+        ...str(values.description) ? { description: str(values.description) } : {},
+        ...firstOwner ? { owner: firstOwner } : {}
+      }, io);
+    }
+    if (command === "tag")
+      return featureTag(root, arg, rest, { ...by ? { by } : {} }, io);
+    if (command === "merge")
+      return featureMerge(root, arg, rest, { ...by ? { by } : {} }, io);
+    if (command === "split")
+      return featureSplit(root, arg, rest, {
+        ...by ? { by } : {},
+        ...str(values.name) ? { name: str(values.name) } : {},
+        ...str(values.into) ? { into: str(values.into) } : {}
+      }, io);
+    if (command === "link") {
+      if (!rest[0]) {
+        io.err("feature link needs a reference, for example: atticus feature link feature.transfers ado:1234");
+        return 2;
+      }
+      return featureLink(root, arg, rest[0], { ...by ? { by } : {}, ...str(values.title) ? { title: str(values.title) } : {} }, io);
+    }
+  }
+  if (group === "critic" && command === "stats")
+    return criticStats(root, { json }, io);
+  if (group === "critic") {
+    if (!command) {
+      io.err("critic needs a change id, for example: atticus critic add-transfer-limit --gate design");
+      return 2;
+    }
+    return critic(root, command, {
+      ...str(values.gate) ? { gate: str(values.gate) } : {},
+      ...str(values.lens) ? { lens: str(values.lens) } : {},
+      ...str(values.mode) ? { mode: str(values.mode) } : {},
+      ...values.resume ? { resume: true } : {},
+      json
+    }, io);
+  }
+  if (group === "findings") {
+    if (!command) {
+      io.err("findings needs a change id");
+      return 2;
+    }
+    return findings(root, command, { json }, io);
+  }
+  if (group === "finding") {
+    const [findingId, action] = positionals.slice(2);
+    if (!command || !findingId || !action) {
+      io.err('finding needs a change, a finding id and an action, for example: atticus finding add-transfer-limit f-1 not-relevant --reason "..."');
+      return 2;
+    }
+    const session = given ? void 0 : (await import("./chunk-7SZPENUP.js")).assistantSession(process.env);
+    if (session)
+      io.err(`Recorded as ${session.by}: ${session.because}.`);
+    return findingAction(root, command, findingId, action, {
+      by: session?.by ?? who(),
+      ...str(values.reason) ? { reason: str(values.reason) } : {},
+      ...str(values["asked-of"]) ? { askedOf: str(values["asked-of"]) } : {},
+      ...str(values.edit) ? { edit: str(values.edit) } : {},
+      ...str(values.gate) ? { gate: str(values.gate) } : {}
+    }, io);
+  }
+  if (group === "change") {
+    const list = (v) => Array.isArray(v) ? v : typeof v === "string" ? [v] : void 0;
+    const repo = str(values.repo);
+    if (command === "new")
+      return changeNew(root, {
+        ...arg ? { title: arg } : {},
+        ...str(values.type) ? { type: str(values.type) } : {},
+        ...str(values.template) ? { template: str(values.template) } : {},
+        ...str(values.id) ? { id: str(values.id) } : {},
+        by: who(),
+        ...list(values.owner) ? { owners: list(values.owner) } : {},
+        ...list(values.system) ? { systems: list(values.system) } : {},
+        ...str(values.like) ? { like: str(values.like) } : {},
+        ...str(values.impact) ? { impact: str(values.impact) } : {}
+      }, io);
+    if (command === "impact") {
+      const { changeImpactCli } = await import("./chunk-Z2EYRUOH.js");
+      return changeImpactCli(root, arg, { json }, io);
+    }
+    if (command === "similar") {
+      const { changeSimilarCli } = await import("./chunk-RIEFYHXI.js");
+      const limit = Number(str(values.limit) ?? 5);
+      return changeSimilarCli(root, arg, {
+        json,
+        ...Number.isFinite(limit) && limit > 0 ? { limit } : {},
+        ...str(values.change) ? { change: str(values.change) } : {}
+      }, io);
+    }
+    if (command === "list")
+      return changeList(root, { json }, io);
+    if (command === "export") {
+      const { changeExportCommand } = await import("./chunk-SH7AZZDA.js");
+      const named = positionals[3];
+      const fmt = str(values.format) ?? (named === "ado" || named === "jira" ? named : void 0);
+      return changeExportCommand(root, arg, {
+        ...fmt ? { format: fmt } : {},
+        ...str(values.out) ? { out: str(values.out) } : {},
+        ...str(values.area) ? { areaPath: str(values.area) } : {},
+        ...str(values.iteration) ? { iterationPath: str(values.iteration) } : {}
+      }, io);
+    }
+    if (command === "conflicts")
+      return changeConflicts(root, { json }, io);
+    if (command === "conform") {
+      if (!arg) {
+        io.err("change conform needs a change id, for example: atticus change conform add-transfer-limit");
+        return 2;
+      }
+      const { changeConformCommand } = await import("./chunk-DYWTQXP4.js");
+      return changeConformCommand(root, arg, {
+        ...str(values.repo) ? { repo: str(values.repo) } : {},
+        ...str(values.ref) ? { ref: str(values.ref) } : {},
+        ...str(values.task) ? { task: str(values.task) } : {},
+        latest: values.latest === true,
+        json
+      }, io);
+    }
+    if (command === "estimate") {
+      if (!arg) {
+        io.err("change estimate needs a change id, for example: atticus change estimate add-transfer-limit");
+        return 2;
+      }
+      const { changeEstimateCommand } = await import("./chunk-NDW4ROST.js");
+      return changeEstimateCommand(root, arg, { json }, io);
+    }
+    if (command === "map") {
+      if (!arg) {
+        io.err("change map needs a change id, for example: atticus change map add-transfer-limit");
+        return 2;
+      }
+      const { changeMapCommand } = await import("./chunk-ACWQDL6T.js");
+      return changeMapCommand(root, arg, { ...str(values.format) ? { format: str(values.format) } : {}, json }, io);
+    }
+    if (command === "learn")
+      return changeLearn(root, { json }, io);
+    if (command === "draft")
+      return changeDraft(root, arg, {
+        ...str(values.attempts) ? { attempts: Number(str(values.attempts)) } : {},
+        force: values.force === true,
+        ...str(values.resume) ? { resume: str(values.resume) } : {},
+        ...str(values.mode) ? { mode: str(values.mode) } : {},
+        json
+      }, io);
+    if (!arg) {
+      io.err(`change ${command ?? ""} needs a change id, for example: atticus change status add-transfer-limit`);
+      return 2;
+    }
+    if (command === "status")
+      return changeStatus(root, arg, { json }, io);
+    if (command === "knowledge") {
+      const { changeKnowledge } = await import("./chunk-UNFCFJMF.js");
+      return changeKnowledge(root, arg, {
+        ...str(values.confirm) ? { confirm: str(values.confirm) } : {},
+        ...str(values.exclude) ? { exclude: str(values.exclude) } : {},
+        json
+      }, io);
+    }
+    const approve = values.approve === true;
+    if (command === "handoff")
+      return changeHandoff(root, arg, {
+        by: who(),
+        approve,
+        ...repo ? { repo } : {},
+        ...str(values.base) ? { base: str(values.base) } : {}
+      }, io);
+    if (command === "sync")
+      return changeSync(root, arg, { ...approve ? { by: who() } : {}, approve, ...repo ? { repo } : {} }, io);
+    if (command === "return")
+      return changeReturn(root, arg, {
+        by: who(),
+        approve,
+        ...str(values.reason) ? { reason: str(values.reason) } : {},
+        ...repo ? { repo } : {}
+      }, io);
+    if (command === "archive" && await ciArchiveGate(root, arg, { json: false }, io) !== 0)
+      return 1;
+    if (command === "archive")
+      return changeArchive(root, arg, { by: who(), ...values["no-rescan"] === true ? { rescan: false } : {} }, io);
+  }
+  if (group === "intake" && command === "add")
+    return intakeAdd(root, positionals.slice(2).map((f) => resolve(f)), io);
+  if (group === "intake" && command === "list")
+    return intakeList(root, io, { json });
+  if (group === "intake" && command === "traffic") {
+    const { intakeTraffic } = await import("./chunk-5ICB2BXH.js");
+    return intakeTraffic(root, positionals[2] ?? "", {
+      ...str(values.source) ? { source: str(values.source) } : {},
+      ...str(values.from) ? { from: str(values.from) } : {},
+      ...str(values.to) ? { to: str(values.to) } : {},
+      json
+    }, io);
+  }
+  if (group === "intake" && command === "impact") {
+    const { intakeImpact } = await import("./chunk-RB2VSED2.js");
+    return intakeImpact(root, positionals[2] ?? "", { json }, io);
+  }
+  if (group === "triage" && !command)
+    return triageList(root, io, { json });
+  if (group === "triage" && command === "decide") {
+    const [item, option] = positionals.slice(2);
+    if (!item || !option || !num(option)) {
+      io.err("triage decide needs an item id and an option number, for example: atticus triage decide alias-needed.ledger-platform 1");
+      return 2;
+    }
+    return triageDecide(root, item, num(option), {
+      by: who(),
+      ...str(values.reason) ? { reason: str(values.reason) } : {}
+    }, io);
+  }
+  if (group === "diagram" && command === "render") {
+    if (!arg) {
+      io.err("diagram render needs a view or a file, for example: atticus diagram render context");
+      return 2;
+    }
+    return diagramRender(root, {
+      view: arg,
+      ...str(values.focus) ? { focus: str(values.focus) } : {},
+      ...str(values.format) ? { format: str(values.format) } : {},
+      ...str(values.out) ? { out: str(values.out) } : {}
+    }, io);
+  }
+  if (group === "diagram" && command === "library") {
+    if (!arg) {
+      io.err("diagram library needs a file to write, for example: atticus diagram library atticus.xml");
+      return 2;
+    }
+    return diagramLibrary(arg, io);
+  }
+  if (group === "stub" && command === "serve") {
+    if (!arg) {
+      io.err("stub serve needs a spec file or a catalog id, for example: atticus stub serve api/openapi.yaml");
+      return 2;
+    }
+    return stubServe(root, arg, {
+      ...num(values.port) ? { port: num(values.port) } : {},
+      ...str(values.host) ? { host: str(values.host) } : {},
+      catalog: values["from-catalog"] === true
+    }, io);
+  }
+  if (group === "stub" && command === "check") {
+    if (!arg) {
+      io.err("stub check needs a spec file");
+      return 2;
+    }
+    return stubCheck(arg, io);
+  }
+  if (group === "onboard") {
+    const list = (v) => (str(v) ?? "").split(",").map((x) => x.trim()).filter(Boolean);
+    const fwOptions = () => ({
+      ...str(values.from) ? { from: str(values.from) } : {},
+      ...list(values.users).length ? { users: list(values.users) } : {},
+      ...list(values.package).length ? { packages: list(values.package) } : {}
+    });
+    if ((command === "check" || command === "accept") && arg === "framework") {
+      const name = positionals[3];
+      if (!name) {
+        io.err(`onboard ${command} framework needs the model's name: atticus onboard ${command} framework <name>`);
+        return 2;
+      }
+      return command === "check" ? onboardFrameworkCheck(root, name, fwOptions(), io) : onboardFrameworkAccept(root, name, { replace: values.replace === true }, io);
+    }
+    if (command === "framework") {
+      if (!arg) {
+        io.err("onboard framework needs a name and the framework's source: atticus onboard framework <name> --from <source|jar|tgz> [--users <repo>,...]");
+        return 2;
+      }
+      const attempts2 = Number(str(values.attempts) ?? "3");
+      if (!Number.isInteger(attempts2) || attempts2 < 1 || attempts2 > 10) {
+        io.err("--attempts is a whole number from 1 to 10.");
+        return 2;
+      }
+      let runtime;
+      if (values["no-ai"] !== true)
+        try {
+          runtime = (await runtimeForCli(root, { ...str(values.mode) ? { mode: str(values.mode) } : {} })).runtime;
+        } catch (e) {
+          if (e instanceof (await loadAi()).AiOffError)
+            io.out("AI is off here: the learned model alone is checked.");
+          else if (e instanceof (await loadAi()).RuntimeConfigError) {
+            io.err(e.message);
+            return 2;
+          } else
+            throw e;
+        }
+      return onboardFramework(root, arg, { ...fwOptions(), attempts: attempts2 }, { ...runtime ? { runtime } : {} }, io);
+    }
+    if (command === "check") {
+      const repo = str(values.repo);
+      if (!arg || !repo) {
+        io.err("onboard check needs a proposal and its repo: atticus onboard check <name> --repo <repo>");
+        return 2;
+      }
+      return onboardCheck(root, arg, repo, io);
+    }
+    if (command === "accept") {
+      if (!arg) {
+        io.err("onboard accept needs the proposal's name: atticus onboard accept <name>");
+        return 2;
+      }
+      return onboardAccept(root, arg, { replace: values.replace === true }, io);
+    }
+    if (command === "eval") {
+      if (!arg) {
+        io.err("onboard eval needs a folder of cases: atticus onboard eval fixtures/onboard-eval --mode model");
+        return 2;
+      }
+      try {
+        const { runtime } = await runtimeForCli(root, {
+          ...str(values.mode) ? { mode: str(values.mode) } : {}
+        });
+        return await onboardEval(root, arg, { json }, { runtime }, io);
+      } catch (e) {
+        if (e instanceof (await loadAi()).RuntimeConfigError) {
+          io.err(e.message);
+          return 2;
+        }
+        throw e;
+      }
+    }
+    if (!command) {
+      io.err("onboard needs a repo: atticus onboard <repo-id|folder> [--name <dialect>] [--attempts 3] [--mode model]");
+      return 2;
+    }
+    const attempts = Number(str(values.attempts) ?? "3");
+    if (!Number.isInteger(attempts) || attempts < 1 || attempts > 10) {
+      io.err("--attempts is a whole number from 1 to 10.");
+      return 2;
+    }
+    try {
+      const { runtime } = await runtimeForCli(root, {
+        ...str(values.mode) ? { mode: str(values.mode) } : {}
+      });
+      return await onboardDraft(root, command, { ...str(values.name) ? { name: str(values.name) } : {}, attempts }, { runtime }, io);
+    } catch (e) {
+      if (e instanceof (await loadAi()).RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  }
+  if (group === "frameworks" && command === "check")
+    return frameworksCheck(root, arg, io);
+  if (group === "frameworks" && command === "kit")
+    return frameworksKit(resolve(arg ?? "frameworks-kit"), io);
+  if (group === "frameworks" && command === "survey") {
+    const pkg = str(values.package);
+    return frameworksSurvey(root, {
+      prefixes: pkg ? pkg.split(",").map((x) => x.trim()).filter(Boolean) : [],
+      json: values.json === true
+    }, io);
+  }
+  if (group === "frameworks" && command === "discover") {
+    const strings = (v) => (Array.isArray(v) ? v : []).filter((x) => typeof x === "string");
+    const groups = strings(values.group).flatMap((g) => g.split(",")).map((g) => g.trim()).filter(Boolean);
+    return frameworksDiscover(root, {
+      groups,
+      jars: strings(values.jars),
+      learn: values.learn === true,
+      json: values.json === true
+    }, io);
+  }
+  if (group === "frameworks") {
+    const from = str(values.from);
+    if (command !== "learn" || !arg || !from) {
+      io.err("frameworks learn needs a name and the starter's source, for example: atticus frameworks learn tide-platform --from workspace/tide-platform");
+      return 2;
+    }
+    const pkg = str(values.package);
+    return frameworksLearn(root, arg, from, {
+      ...pkg ? { packages: pkg.split(",").map((x) => x.trim()) } : {},
+      dryRun: values["dry-run"] === true
+    }, io);
+  }
+  if (group === "plugin" && (command === "test" || command === "pin" || command === "add")) {
+    if (!arg) {
+      io.err(`plugin ${command} needs a plugin id, for example: atticus plugin ${command} ${command === "add" ? "vertex" : "forge-routes"}`);
+      return 2;
+    }
+    return command === "test" ? pluginTest(root, arg, io) : command === "pin" ? pluginPin(root, arg, io) : pluginAdd(root, arg, io);
+  }
+  if (group === "dialect") {
+    const rest = positionals.slice(3);
+    if (command === "kit")
+      return dialectKit(resolve(arg ?? "dialect-kit"), io);
+    if (command === "tree") {
+      if (!arg) {
+        io.err("dialect tree needs a file: atticus dialect tree src/A.java [--language java]");
+        return 2;
+      }
+      return dialectTree(arg, { ...str(values.language) ? { language: str(values.language) } : {} }, io);
+    }
+    if (!arg) {
+      io.err(`dialect ${command ?? ""} needs a dialect name, for example: atticus dialect test forge`.replace("  ", " "));
+      return 2;
+    }
+    if (command === "new") {
+      const repos = [...str(values.from)?.split(",") ?? [], ...rest].map((r) => r.trim()).filter(Boolean);
+      if (repos.length === 0) {
+        io.err("dialect new needs sample repos, for example: atticus dialect new forge --from workspace/forge-ledger");
+        return 2;
+      }
+      return dialectNew(root, arg, repos, io);
+    }
+    if (command === "test")
+      return dialectTest(root, arg, io);
+    if (command === "run") {
+      if (!rest[0]) {
+        io.err("dialect run needs a repo folder, for example: atticus dialect run forge workspace/forge-ledger");
+        return 2;
+      }
+      return dialectRun(root, arg, rest[0], { json }, io);
+    }
+    if (command === "grade") {
+      if (!rest[0]) {
+        io.err("dialect grade needs a dialect file and an eval folder");
+        return 2;
+      }
+      return dialectGrade(arg, rest[0], io);
+    }
+  }
+  if (group === "sources" && command === "tag" || group === "knowledge" || group === "bench" && command === "knowledge") {
+    const handled = await knowledgeCli(root, positionals, values, io, who);
+    if (handled !== void 0)
+      return handled;
+  }
+  if (group === "sources" && command === "add") {
+    const [kind, location] = positionals.slice(2);
+    if (!kind || !location) {
+      io.err("sources add needs a type and a location, for example: atticus sources add markdown-folder ../wiki");
+      return 2;
+    }
+    const listOf = (v) => typeof v === "string" ? v.split(",").map((x) => x.trim()).filter(Boolean) : void 0;
+    return sourcesAdd(root, kind, location, io, {
+      ...str(values.id) ? { id: str(values.id) } : {},
+      ...str(values.path) ? { path: str(values.path) } : {},
+      ...str(values.ref) ? { ref: str(values.ref) } : {},
+      ...values.submodule === true ? { submodule: true } : {},
+      ...listOf(values.kind) ? { kinds: listOf(values.kind) } : {},
+      ...listOf(values.framework) ? { frameworks: listOf(values.framework) } : {},
+      ...Array.isArray(values.owner) && values.owner[0] ? { owner: String(values.owner[0]) } : {},
+      ...values.save === true ? { save: true } : {}
+    });
+  }
+  if (group === "sources" && command === "refresh")
+    return sourcesRefreshCommand(root, { json }, io);
+  if (group === "sources" && command === "estimate") {
+    const bt = str(values["batch-tokens"]);
+    return (await import("./chunk-77RSRG3A.js")).sourcesEstimate(root, {
+      ...str(values.source) ? { source: str(values.source) } : {},
+      ...bt && Number(bt) > 0 ? { batchTokens: Number(bt) } : {},
+      ...values.full === true ? { full: true } : {},
+      json: values.json === true
+    }, io);
+  }
+  if (group === "standards")
+    return (await import("./chunk-77RSRG3A.js")).standardsCli(root, command, values, io);
+  if (group === "sources" && command === "sync")
+    return sourcesSync(root, io, {
+      json: values.json === true,
+      ...str(values.source) ? { source: str(values.source) } : {}
+    });
+  if (group === "patterns" && command === "scan")
+    return patternsScan(root, io, { json: values.json === true });
+  if (group === "coverage")
+    return coverageCommand(root, io, { json: values.json === true });
+  if (group === "domain" && command === "profile")
+    return domainProfileCommand(root, arg, str(values.out) ? { out: str(values.out) } : {}, io);
+  if (group === "questions" && command)
+    return questionsFiles(root, argv, io);
+  if (group === "questions")
+    return questionsCommand(root, io, { json: values.json === true });
+  if (group === "reconcile")
+    return reconcileCommand(root, positionals.slice(1), { json: values.json === true }, io);
+  if (group === "orgpack" && (command === "draft" || command === "accept"))
+    return (await import("./chunk-4UZJOQYK.js")).orgPackDraftCli(root, command, arg, values, io);
+  if (group === "orgpack" && command === "owner")
+    return (await import("./chunk-KXZR2BLL.js")).orgPackOwnerCli(root, arg, io);
+  if (group === "orgpack" && command === "validate")
+    return orgPackValidate(arg ? resolve(arg) : join((await import("./chunk-IVHN2VYG.js")).orgPackDirOf(root)), io);
+  if (group === "stage" && command === "check")
+    return (await import("./chunk-JBSD57N7.js")).stageCheck(root, arg, positionals[3], positionals[4], io);
+  if (group === "handoff" && command === "done") {
+    if (!arg) {
+      io.err("handoff done needs the run id from the prompt, for example: atticus handoff done run-20261018060000-0001");
+      return 2;
+    }
+    if (await (await import("./chunk-YWOMGMZB.js")).isTaskRun(root, arg))
+      return taskHandoff(root, arg, {
+        by: who(),
+        approve: values.approve === true,
+        json
+      }, io);
+    return handoffDone(root, arg, io, str(values.model) ? { model: str(values.model) } : {});
+  }
+  if (group === "openspec" && command === "setup")
+    return openspecSetup(root, io);
+  if (group === "openspec" && command === "check")
+    return openspecCheck(root, io);
+  if (group === "openspec") {
+    const { openspecRun } = await import("./chunk-U5PDQTLA.js");
+    return openspecRun(root, openspecArgsOf(argv), io);
+  }
+  if (group === "workspace" && command === "sync")
+    return workspaceSync(root, repoIds, io, str(values.from) ? { from: resolve(str(values.from)) } : {});
+  if (group === "workspace" && (command === "open" || command === "prune")) {
+    if (!arg) {
+      io.err(`workspace ${command} needs a change id, for example: atticus workspace ${command} add-transfer-limit`);
+      return 2;
+    }
+    if (command === "open")
+      return workspaceOpen(root, arg, repoIds, io);
+    return workspacePrune(root, arg, { all: values.all === true, force: values.force === true }, io);
+  }
+  const { commandCatalog } = await import("./chunk-O6ILVBYB.js");
+  const { nearestCommand } = await import("./chunk-4SKZDI62.js");
+  const near = nearestCommand(positionals, commandCatalog(HELP).map((c) => c.id));
+  io.err(`Unknown command: ${positionals.join(" ")}.${near ? ` Did you mean atticus ${near}?` : ""}`);
+  io.err("atticus help lists the main commands, atticus legacy the rest; atticus help <command> explains one.");
+  return 2;
+}
+var QUESTION_FLAGS = ["state", "option", "text", "scope", "type"];
+async function checkFlags(argv, positionals, io) {
+  const { unknownFlags, unknownFlagMessages } = await import("./chunk-4SKZDI62.js");
+  const quick = /* @__PURE__ */ new Set([...Object.keys(OPTIONS), ...QUESTION_FLAGS, "handoff"]);
+  if (!unknownFlags(argv, quick).length)
+    return void 0;
+  const { commandCatalog } = await import("./chunk-O6ILVBYB.js");
+  const catalog = commandCatalog(HELP);
+  const known = /* @__PURE__ */ new Set([
+    ...quick,
+    ...catalog.flatMap((c) => c.flags.map((f) => f.name.replace(/^--/, "")))
+  ]);
+  const unknown = unknownFlags(argv, known);
+  if (!unknown.length)
+    return void 0;
+  for (const m of unknownFlagMessages(unknown, known))
+    io.err(m);
+  const { commandOf } = await import("./chunk-TQYBXDVH.js");
+  const id = commandOf(positionals, catalog.map((c) => c.id));
+  io.err(id ? `atticus help ${id} lists what it takes. Nothing was run.` : "atticus help --all lists every command and what it takes. Nothing was run.");
+  return 2;
+}
+export {
+  HELP_TEXT,
+  VERSION,
+  main,
+  setUpAi
+};