@mutmutco/cli 3.105.11 → 3.105.12

package/dist/main.cjs

@@ -19506,6 +19506,102 @@ function applyChecklistCheck(body, query, checked) {
   return { ok: true, edit: setChecklistMarker(body, sel.item, checked), item: sel.item };
 }
 
+// src/house-map.ts
+var HOUSE_ROOTS = ["oracle", "harbour", "devops", "vault", "learning"];
+function isHouseRoot(token) {
+  return HOUSE_ROOTS.includes(token);
+}
+var COMPAT_SHIM_DEATH_WAVE = "Wave 3";
+var COMPAT_SHIM_NOTE = `compatibility shim \u2014 the flat Wave 0 path; use the canonical house-prefixed form; dies in ${COMPAT_SHIM_DEATH_WAVE} (#4316)`;
+var HOUSE_QUESTIONS = {
+  oracle: "Is it live?",
+  harbour: "Is it bounded?",
+  devops: "Is it legal?",
+  vault: "Is it guarded?",
+  learning: "Did it learn?",
+  core: "Is it one door?"
+};
+var HOUSE_MAP = {
+  // --- oracle — live truth ------------------------------------------------------------------------
+  board: "oracle",
+  // board management (read + the guarded mutations that keep it live)
+  issue: "oracle",
+  // issues are live org truth
+  find: "oracle",
+  // estate search door
+  "repo-index": "oracle",
+  // Hub cloud + local pointer index
+  wave: "oracle",
+  // read-side multi-worktree board visibility (`wave status`)
+  next: "oracle",
+  // read-side board: the next actionable item
+  docs: "oracle",
+  // generated docs surfaces — the live org knowledge routing index
+  org: "oracle",
+  // org projects/registry/access reads (subgroup overrides below)
+  "org project": "oracle",
+  // registry projections (declared + projected live truth)
+  "org access": "oracle",
+  // org access role/audit reads
+  "org config": "oracle",
+  // live org configuration read
+  // --- harbour — declared lanes -------------------------------------------------------------------
+  "org schedules": "harbour",
+  // register/run/park schedule rows under the one lane contract
+  // --- devops — shipping --------------------------------------------------------------------------
+  pr: "devops",
+  ci: "devops",
+  // the CI/gate audit
+  rcand: "devops",
+  release: "devops",
+  hotfix: "devops",
+  train: "devops",
+  "wave land": "devops",
+  // the write-side serial merge train is shipping, not board observation
+  bootstrap: "devops",
+  // repo provisioning + propagate
+  runtime: "devops",
+  // tenant/deploy/box/edge — shipping and central deploy
+  "org rules": "devops",
+  // org-managed repository rule delivery (.gitignore)
+  // --- vault — secrets ----------------------------------------------------------------------------
+  secrets: "vault",
+  "org oauth": "vault",
+  // OAuth credential planning/set/verify
+  // --- learning — self-improvement ----------------------------------------------------------------
+  report: "learning",
+  // friction reports
+  "skill-lesson": "learning",
+  // --- core — the front door itself ---------------------------------------------------------------
+  commands: "core",
+  whoami: "core",
+  worktree: "core",
+  spawn: "core",
+  // this repo's process-spawn contract
+  tests: "core",
+  // this repo's test-policy contract
+  doctor: "core",
+  stage: "core",
+  plugin: "core",
+  // plugin lifecycle + guards (CLI house owns plugins)
+  explain: "core",
+  // command-surface help
+  status: "core",
+  // repo-orientation snapshot (front door — torn toward oracle, kept core)
+  onboard: "core"
+  // repo-readiness orientation (front door — torn toward oracle, kept core)
+};
+function houseForPath(path2) {
+  if (path2 === "") return "core";
+  const segments = path2.split(" ");
+  for (let end = segments.length; end > 0; end -= 1) {
+    const key = segments.slice(0, end).join(" ");
+    const house = HOUSE_MAP[key];
+    if (house) return house;
+  }
+  return void 0;
+}
+
 // src/command-taxonomy.ts
 var COMMAND_METADATA = /* @__PURE__ */ Symbol.for("mmi.commandTaxonomy.metadata");
 var PRIMARY_GROUPS = [
@@ -19683,9 +19779,6 @@ function applyCommandTaxonomy(program3) {
 function commandTaxonomyRank(name) {
   return TOP_LEVEL_ORDER.get(name) ?? Number.MAX_SAFE_INTEGER;
 }
-function commandHelpGroupRank(group) {
-  return HELP_GROUP_ORDER.get(group) ?? Number.MAX_SAFE_INTEGER;
-}
 function isCanonicalSuggestion(metadata) {
   return metadata.category !== "internal";
 }
@@ -19766,9 +19859,16 @@ function buildCommand(cmd, path2) {
     module_owner: "unclassified",
     consumer: "unclassified"
   };
+  const house = houseForPath(path2);
+  if (!house) {
+    throw new Error(
+      `command-manifest: command '${path2}' has no house assignment \u2014 add it to cli/src/house-map.ts (the six-house taxonomy; every top-level command maps to exactly one house).`
+    );
+  }
   const out = {
     name: cmd.name(),
     path: path2,
+    house,
     arguments: cmd.registeredArguments.map(buildArgument),
     // A hand-parsed command registers no Commander options, so its declared set is merged in (#3682).
     options: [...cmd.options.map(buildOption), ...readDeclaredOptions(cmd)],
@@ -19778,6 +19878,7 @@ function buildCommand(cmd, path2) {
     ...metadata
   };
   if (cmd._allowUnknownOption) out.parses_own_argv = true;
+  if (path2 && house !== "core") out.shim = true;
   const description = cmd.description();
   if (description) out.description = description;
   const examples = readExamples(cmd);
@@ -19803,6 +19904,22 @@ function collectLeaves(node, acc) {
   }
   for (const child2 of node.subcommands) collectLeaves(child2, acc);
 }
+function buildHouses(tree) {
+  const collect = (node, parentHouse, root, out) => {
+    if (node.house === root && parentHouse !== root) {
+      const entry = { path: node.path };
+      if (node.description) entry.description = node.description;
+      out.push(entry);
+    }
+    for (const child2 of node.subcommands) collect(child2, node.house, root, out);
+  };
+  return HOUSE_ROOTS.map((root) => {
+    const commands = [];
+    for (const top of tree.subcommands) collect(top, void 0, root, commands);
+    commands.sort((a, b) => a.path.localeCompare(b.path));
+    return { root, question: HOUSE_QUESTIONS[root], commands };
+  });
+}
 function buildCommandManifest(program3) {
   const tree = buildCommand(program3, "");
   const index = [];
@@ -19816,6 +19933,13 @@ function buildCommandManifest(program3) {
     name: tree.name,
     tree,
     index,
+    houses: buildHouses(tree),
+    shim_contract: {
+      canonical: "mmi-cli <house> <command> \u2026",
+      shim: "mmi-cli <command> \u2026",
+      dies: COMPAT_SHIM_DEATH_WAVE,
+      note: COMPAT_SHIM_NOTE
+    },
     primary_tree: primaryTree,
     primary_index: primaryIndex,
     error_codes: ERROR_CODE_REFERENCE
@@ -19852,16 +19976,26 @@ function formatManifestHuman(manifest, options = {}) {
     }
     if (options.all) for (const child2 of node.subcommands) render(child2, depth + 1);
   };
-  let currentGroup;
-  const rootCommands = [...root.subcommands].sort((a, b) => commandHelpGroupRank(a.help_group) - commandHelpGroupRank(b.help_group) || commandTaxonomyRank(a.name) - commandTaxonomyRank(b.name));
-  for (const command of rootCommands) {
-    if (command.help_group !== currentGroup) {
-      currentGroup = command.help_group;
-      lines.push("", `${currentGroup}:`);
-    }
-    render(command, 1);
-  }
-  lines.push("", options.all ? "Use `mmi-cli explain <group|command>` for a focused map." : "Use `mmi-cli explain <group|command>` for detail or `mmi-cli commands --all` for operational depth.");
+  const forHouse = (node, house) => {
+    const subcommands = node.subcommands.map((child2) => forHouse(child2, house)).filter((child2) => Boolean(child2));
+    if (node.house === house) return { ...node, subcommands };
+    return subcommands.length ? { ...node, subcommands } : void 0;
+  };
+  const renderHouse = (house, label) => {
+    const members = root.subcommands.map((command) => forHouse(command, house)).filter((command) => Boolean(command)).sort((a, b) => commandTaxonomyRank(a.name) - commandTaxonomyRank(b.name));
+    if (!members.length) return;
+    lines.push("", `${label}:`);
+    for (const member of members) render(member, 1);
+  };
+  for (const house of HOUSE_ROOTS) renderHouse(house, `${house} \u2014 ${HOUSE_QUESTIONS[house]}`);
+  renderHouse("core", `core \u2014 ${HOUSE_QUESTIONS.core}`);
+  lines.push(
+    "",
+    `Canonical form: \`mmi-cli <house> <command> \u2026\`. The flat paths above are compatibility shims,`,
+    `kept for one window so fleet scripts keep working \u2014 they die in ${COMPAT_SHIM_DEATH_WAVE} (#4316).`,
+    "",
+    options.all ? "Use `mmi-cli explain <group|command>` for a focused map." : "Use `mmi-cli explain <group|command>` for detail or `mmi-cli commands --all` for operational depth."
+  );
   return lines.join("\n");
 }
 
@@ -35286,6 +35420,14 @@ function envelopeAwareWriteErr(str) {
 }
 var program2 = new Command();
 program2.name("mmi-cli").description("MMI Future Hub CLI ? the org control plane for agentic coding.").version(resolveClientVersion()).configureOutput({ writeErr: envelopeAwareWriteErr }).showHelpAfterError(PARSE_HINT_SENTINEL);
+program2.addHelpText(
+  "before",
+  `Houses (canonical roots): oracle \xB7 harbour \xB7 devops \xB7 vault \xB7 learning
+  \`mmi-cli <house> <command> \u2026\` is the canonical form; the flat \`mmi-cli <command> \u2026\` paths below
+  are compatibility shims that die in ${COMPAT_SHIM_DEATH_WAVE} (#4316). \`mmi-cli commands\` shows the
+  house-shaped tree; \`mmi-cli <house> --help\` lists one house.
+`
+);
 function appActorDeps() {
   return {
     fetchSecret: async (key) => fetchSecretValue(makeSecretsDeps(await loadConfig()), key, { repo: APP_VAULT_REPO }),
@@ -38319,6 +38461,61 @@ program2.command("session-start").description("run the SessionStart verbs (whoam
 installProcessBackstop();
 consolidateCommandNamespaces(program2);
 applyCommandTaxonomy(program2);
+function resolveHouseShim(argv) {
+  const houseToken = argv[2];
+  if (!houseToken) return;
+  if (!isHouseRoot(houseToken)) {
+    return;
+  }
+  const remainder = argv.slice(3);
+  const first = remainder[0];
+  if (!first || first === "--help" || first === "-h") {
+    printHouseRootHelp(houseToken);
+    hardExit(0);
+  }
+  const commandTokens = remainder.slice(0, 2).filter((tok) => !tok.startsWith("-"));
+  const lookupPath = commandTokens.join(" ");
+  if (!lookupPath) {
+    printHouseRootHelp(houseToken);
+    hardExit(2);
+  }
+  const actual = houseForPath(lookupPath);
+  if (actual === houseToken) {
+    argv.splice(2, 1);
+    return;
+  }
+  const canonical = actual ? `mmi-cli ${actual === "core" ? "" : `${actual} `}${lookupPath}`.replace(/\s+/g, " ").trim() : void 0;
+  if (actual) {
+    process.stderr.write(
+      `mmi-cli ${houseToken}: '${lookupPath}' lives in house '${actual}' \u2014 run: ${canonical} \u2026
+`
+    );
+  } else {
+    process.stderr.write(
+      `mmi-cli ${houseToken}: '${first}' is not a command of house '${houseToken}' \u2014 run \`mmi-cli ${houseToken} --help\` for its commands
+`
+    );
+  }
+  hardExit(2);
+}
+function printHouseRootHelp(house) {
+  const manifest = buildCommandManifest(program2);
+  const commands = manifest.houses.find((entry) => entry.root === house)?.commands ?? [];
+  const lines = [
+    `mmi-cli ${house} \u2014 the ${house} house (${HOUSE_QUESTIONS[house]}), ${commands.length} command${commands.length === 1 ? "" : "s"}:`,
+    ""
+  ];
+  for (const cmd of commands) {
+    lines.push(cmd.description ? `  ${cmd.path} \u2014 ${cmd.description}` : `  ${cmd.path}`);
+  }
+  lines.push(
+    "",
+    `Canonical: \`mmi-cli ${house} <command> \u2026\`. The flat \`mmi-cli <command> \u2026\` form is a compatibility`,
+    `shim keeping fleet scripts working for one window \u2014 shims die in ${COMPAT_SHIM_DEATH_WAVE} (#4316).`
+  );
+  consoleIo.log(lines.join("\n"));
+}
+resolveHouseShim(process.argv);
 program2.parseAsync(process.argv).then(() => finishCliRun()).catch((e) => failGraceful(e.message));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "3.105.11",
+  "version": "3.105.12",
   "description": "MMI Future CLI — the org dev toolbox and shared cross-IDE engine for every registry-declared MMI coding surface.",
   "type": "module",
   "license": "UNLICENSED",