@mutmutco/cli 2.37.0 → 2.38.1

package/README.md

@@ -55,7 +55,7 @@ mmi-cli doctor --json
 - `mmi-cli rcand`, `release`, and `hotfix` render guarded train plans; product trains trigger the Hub's central tenant deployer, while MMI-Hub releases directly from `development` to `main`.
 - `mmi-cli bootstrap`, `bootstrap verify`, and `bootstrap apply` plan, audit, and seed repo onboarding.
 - `mmi-cli access audit` checks collaborator roles and train-branch allowlists.
-- `mmi-cli scrooge report` reads `.mmi/scrooge/trace.jsonl` and prints per-session char/token savings from the org Scrooge PostToolUse hook (Claude Code).
+- `mmi-cli throttle report` reads `.mmi/throttle/trace.jsonl` and prints gate denial stats from the org Scrooge v2 Read/Shell gates (Claude Code + Cursor IDE) — files ≥50 KB require an explicit positive Read `limit`; output separates `denied (block)` vs `would-block (observe)`.
 - `mmi-cli doctor` checks GitHub auth, repo config, CLI availability, plugin install/config/version state, and stale MMI plugin cache dirs, auto-repairing the safe gaps.
 
 Hub API calls do not send the raw GitHub token on every request. The CLI exchanges it at `/auth/session`

package/dist/index.cjs

@@ -60,26 +60,61 @@ var init_client_version = __esm({
 function setInjectedStdin(payload) {
   injectedStdin = payload;
 }
-function stdinHasPipedInput(statFd = () => (0, import_node_fs2.fstatSync)(0)) {
+function stdinHasPipedInput(statFd = () => (0, import_node_fs2.fstatSync)(0), getIsTTY = () => process.stdin.isTTY) {
   try {
     const stat = statFd();
-    return stat.isFIFO() || stat.isFile();
+    if (stat.isFIFO() || stat.isFile()) return true;
+    if (stat.isCharacterDevice()) return false;
+    if (stat.isSocket()) return false;
+    if (getIsTTY() === true) return false;
+    return true;
   } catch {
     return false;
   }
 }
-async function readStdin() {
+async function readStdin(opts = {}) {
   if (injectedStdin !== void 0) return injectedStdin;
   if (!stdinHasPipedInput()) return "";
+  const maxBytes = opts.maxBytes ?? STDIN_MAX_BYTES;
+  const timeoutMs = opts.timeoutMs ?? STDIN_DRAIN_TIMEOUT_MS;
   const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
+  let total = 0;
+  const drain = (async () => {
+    for await (const chunk of process.stdin) {
+      const buf = chunk;
+      const room = maxBytes - total;
+      if (buf.length >= room) {
+        chunks.push(buf.subarray(0, room));
+        total = maxBytes;
+        break;
+      }
+      chunks.push(buf);
+      total += buf.length;
+    }
+  })().catch(() => {
+  });
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeoutMs);
+  });
+  try {
+    await Promise.race([drain, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    try {
+      process.stdin.unref();
+    } catch {
+    }
+  }
   return Buffer.concat(chunks).toString("utf8");
 }
-var import_node_fs2, injectedStdin;
+var import_node_fs2, injectedStdin, STDIN_MAX_BYTES, STDIN_DRAIN_TIMEOUT_MS;
 var init_stdin_inject = __esm({
   "src/stdin-inject.ts"() {
     "use strict";
     import_node_fs2 = require("node:fs");
+    STDIN_MAX_BYTES = 8 * 1024 * 1024;
+    STDIN_DRAIN_TIMEOUT_MS = 5e3;
   }
 });
 

package/dist/main.cjs

@@ -4113,19 +4113,54 @@ async function hubAuthToken(deps) {
 // src/stdin-inject.ts
 var import_node_fs6 = require("node:fs");
 var injectedStdin;
-function stdinHasPipedInput(statFd = () => (0, import_node_fs6.fstatSync)(0)) {
+function stdinHasPipedInput(statFd = () => (0, import_node_fs6.fstatSync)(0), getIsTTY = () => process.stdin.isTTY) {
   try {
     const stat = statFd();
-    return stat.isFIFO() || stat.isFile();
+    if (stat.isFIFO() || stat.isFile()) return true;
+    if (stat.isCharacterDevice()) return false;
+    if (stat.isSocket()) return false;
+    if (getIsTTY() === true) return false;
+    return true;
   } catch {
     return false;
   }
 }
-async function readStdin() {
+var STDIN_MAX_BYTES = 8 * 1024 * 1024;
+var STDIN_DRAIN_TIMEOUT_MS = 5e3;
+async function readStdin(opts = {}) {
   if (injectedStdin !== void 0) return injectedStdin;
   if (!stdinHasPipedInput()) return "";
+  const maxBytes = opts.maxBytes ?? STDIN_MAX_BYTES;
+  const timeoutMs = opts.timeoutMs ?? STDIN_DRAIN_TIMEOUT_MS;
   const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
+  let total = 0;
+  const drain = (async () => {
+    for await (const chunk of process.stdin) {
+      const buf = chunk;
+      const room = maxBytes - total;
+      if (buf.length >= room) {
+        chunks.push(buf.subarray(0, room));
+        total = maxBytes;
+        break;
+      }
+      chunks.push(buf);
+      total += buf.length;
+    }
+  })().catch(() => {
+  });
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeoutMs);
+  });
+  try {
+    await Promise.race([drain, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    try {
+      process.stdin.unref();
+    } catch {
+    }
+  }
   return Buffer.concat(chunks).toString("utf8");
 }
 
@@ -5138,6 +5173,7 @@ function parseHandoffText(text) {
       northStarSlug,
       summary,
       sourceSessionId,
+      sourceBranch: clean(raw.sourceBranch) || void 0,
       createdAt,
       claimedBySessionId: clean(raw.claimedBySessionId) || void 0,
       closedAt: clean(raw.closedAt) || void 0
@@ -5168,6 +5204,7 @@ function planOpenHandoff(input) {
     northStarSlug,
     summary,
     sourceSessionId,
+    sourceBranch: clean(input.sourceBranch) || void 0,
     createdAt: input.createdAt
   };
 }
@@ -5181,8 +5218,9 @@ function closeHandoff(record, state, at, claimedBySessionId) {
 }
 function formatHandoffLine(item) {
   const r = item.record;
+  const branch = r.sourceBranch ? ` branch:${r.sourceBranch}` : "";
   const suffix = r.state === "claimed" && r.claimedBySessionId ? ` -> ${r.claimedBySessionId}` : "";
-  return `${r.key} [${r.state}] northstar:${r.northStarSlug} source:${r.sourceSessionId}${suffix} - ${r.summary}`;
+  return `${r.key} [${r.state}] northstar:${r.northStarSlug}${branch} source:${r.sourceSessionId}${suffix} - ${r.summary}`;
 }
 
 // src/handoff-commands.ts
@@ -5196,7 +5234,8 @@ async function fetchState(url, qs, retry = FOREGROUND_FETCH) {
   return { key: null, state: { head: body.head } };
 }
 async function fetchScopedSessions(url, project2, branch, retry = FOREGROUND_FETCH) {
-  const qs = new URLSearchParams({ project: project2, branch });
+  const qs = new URLSearchParams({ project: project2 });
+  if (branch) qs.set("branch", branch);
   const res = await fetchWithRetry(fetch, `${url}/saga/sessions?${qs}`, { headers: await hubHeaders() }, retry);
   if (!res.ok) return [];
   const body = await res.json();
@@ -5219,7 +5258,7 @@ async function collectScopedHandoffs(opts = {}) {
   if (!cfg.sagaApiUrl) return { handoffs: [], sessions: [] };
   const key = await sagaKey(cfg);
   const retry = opts.retry ?? FOREGROUND_FETCH;
-  const sessions = await fetchScopedSessions(cfg.sagaApiUrl, key.project, key.branch, retry);
+  const sessions = await fetchScopedSessions(cfg.sagaApiUrl, key.project, void 0, retry);
   const seen = /* @__PURE__ */ new Set();
   const handoffs = [];
   for (const session of sessions) {
@@ -5238,7 +5277,7 @@ async function locateOpenHandoff(key, retry = FOREGROUND_FETCH) {
   const cfg = await loadConfig();
   if (!cfg.sagaApiUrl) return null;
   const scopeKey = await sagaKey(cfg);
-  const sessions = await fetchScopedSessions(cfg.sagaApiUrl, scopeKey.project, scopeKey.branch, retry);
+  const sessions = await fetchScopedSessions(cfg.sagaApiUrl, scopeKey.project, void 0, retry);
   for (const session of sessions) {
     const head = await fetchSessionHead(cfg.sagaApiUrl, session, retry);
     if (!head) continue;
@@ -5277,6 +5316,7 @@ function deriveOpenFields(summary, opts, head, key) {
     northStarSlug: northStarSlug ?? "",
     summary: text ?? "",
     sourceSessionId: key.sessionId,
+    sourceBranch: key.branch,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
@@ -5338,6 +5378,8 @@ async function closeSourceHandoff(key, state, opts = {}, io = consoleIo) {
     return fail(`handoff ${state}: no open handoff matching ${key}`);
   }
   const closed = closeHandoff(located.item.record, state, (/* @__PURE__ */ new Date()).toISOString(), state === "claimed" ? current.sessionId : void 0);
+  const sourceBranch = located.item.record.sourceBranch ?? located.key.branch;
+  const crossBranch = state === "claimed" && !!sourceBranch && sourceBranch !== current.branch;
   await postKeyedNote(located.key, `handoff ${state} ${located.item.record.key}`, {
     handoffClose: { index: located.item.index, closedText: serializeHandoff(closed) }
   });
@@ -5350,9 +5392,16 @@ async function closeSourceHandoff(key, state, opts = {}, io = consoleIo) {
       verified: true
     });
   }
-  if (opts.json) return io.log(JSON.stringify({ ok: true, handoff: closed }));
+  if (opts.json) {
+    return io.log(JSON.stringify({ ok: true, handoff: closed, ...state === "claimed" ? { sourceBranch, crossBranch } : {} }));
+  }
   io.log(`handoff ${state}: ${formatHandoffLine({ index: located.item.index, done: true, record: closed })}`);
+  if (crossBranch) {
+    io.log(`note: opened on branch '${sourceBranch}' (you are on '${current.branch}') \u2014 run \`git switch ${sourceBranch}\` to work where the source session left it.`);
+  }
 }
+var runHandoffAccept = (key, opts = {}, io = consoleIo) => closeSourceHandoff(key, "claimed", opts, io);
+var runHandoffCancel = (key, opts = {}, io = consoleIo) => closeSourceHandoff(key, "cancelled", opts, io);
 async function runHandoffDecline(key, opts = {}, io = consoleIo) {
   const located = await locateOpenHandoff(key);
   if (!located) return fail(`handoff decline: no open handoff matching ${key}`);
@@ -5362,11 +5411,11 @@ async function runHandoffDecline(key, opts = {}, io = consoleIo) {
 function registerHandoffCommands(program3) {
   const handoff = program3.command("handoff").description("explicit saga + North Star handoff lifecycle");
   handoff.command("open [summary]").description("open a handoff bound to the current North Star slug").option("--key <slug|#issue>", "handoff key (defaults to the current North Star slug)").option("--north-star-slug <slug>", "North Star slug to bind (defaults to current saga anchor slug)").option("--message-file <path|->", "read the handoff summary from a UTF-8 file, or from stdin with - (avoids cmd.exe quoting)").option("--json", "machine-readable output").action((summary, opts) => runHandoffOpen(summary, opts));
-  handoff.command("list").description("list open handoffs for the current repo/branch").option("--all", "include claimed/cancelled records").option("--json", "machine-readable output").action(async (opts) => {
+  handoff.command("list").description("list open handoffs for the current repo (any branch)").option("--all", "include claimed/cancelled records").option("--json", "machine-readable output").action(async (opts) => {
     await runHandoffList(opts);
   });
-  handoff.command("accept <key>").description("claim an open handoff and bind this session to its North Star").option("--json", "machine-readable output").action((key, opts) => closeSourceHandoff(key, "claimed", opts));
-  handoff.command("cancel <key>").description("close an open handoff without claiming it").option("--json", "machine-readable output").action((key, opts) => closeSourceHandoff(key, "cancelled", opts));
+  handoff.command("accept <key>").description("claim an open handoff and bind this session to its North Star").option("--json", "machine-readable output").action((key, opts) => runHandoffAccept(key, opts));
+  handoff.command("cancel <key>").description("close an open handoff without claiming it").option("--json", "machine-readable output").action((key, opts) => runHandoffCancel(key, opts));
   handoff.command("decline <key>").description("leave an open handoff unchanged so it is re-offered later").option("--json", "machine-readable output").action((key, opts) => runHandoffDecline(key, opts));
 }
 
@@ -6521,17 +6570,14 @@ function registerHonchoCommands(program3) {
   honcho.command("key").option("--json", "machine-readable output").description("print the resolved honcho identity (workspace, peer, session) \u2014 no write, no key").action((o) => runHonchoKey(o));
 }
 
-// src/scrooge-commands.ts
+// src/throttle-commands.ts
 var import_node_fs11 = require("node:fs");
 var import_node_path9 = require("node:path");
-var SCROOGE_TRACE_PATH = (0, import_node_path9.join)(".mmi", "scrooge", "trace.jsonl");
+var THROTTLE_TRACE_PATH = (0, import_node_path9.join)(".mmi", "throttle", "trace.jsonl");
 function resolveModeFromEnv() {
-  const v = String(process.env.MMI_SCROOGE ?? "conservative").trim().toLowerCase();
-  if (!v || v === "conservative") return "conservative";
-  if (v === "0" || v === "off" || v === "false") return "off";
-  if (v === "normal") return "normal";
-  if (v === "spike") return "spike";
-  return "conservative";
+  const v = String(process.env.MMI_THROTTLE_MODE ?? "block").trim().toLowerCase();
+  if (v === "observe") return "observe";
+  return "block";
 }
 function parseTraceLines(raw) {
   const out = [];
@@ -6547,59 +6593,78 @@ function parseTraceLines(raw) {
   return out;
 }
 function summarizeTrace(entries) {
-  let tools = 0;
-  let charsIn = 0;
-  let charsOut = 0;
-  const passCounts = {};
+  let denials = 0;
+  let readBytesWouldBlock = 0;
+  const byTool = {};
+  const byReason = {};
+  const bySurface = {};
+  const byMode = {};
   for (const e of entries) {
-    tools += 1;
-    charsIn += Number(e.charsIn) || 0;
-    charsOut += Number(e.charsOut) || 0;
-    for (const p of e.passes ?? []) passCounts[p] = (passCounts[p] ?? 0) + 1;
-  }
-  const saved = Math.max(0, charsIn - charsOut);
-  return {
-    tools,
-    charsIn,
-    charsOut,
-    charsSaved: saved,
-    estTokensSaved: Math.round(saved / 4),
-    passCounts
-  };
-}
-function runScroogeReport(io, tracePath = SCROOGE_TRACE_PATH) {
+    denials += 1;
+    const tool = e.tool ?? "unknown";
+    byTool[tool] = (byTool[tool] ?? 0) + 1;
+    const reason = e.reasonId ?? "unknown";
+    byReason[reason] = (byReason[reason] ?? 0) + 1;
+    const surface = e.surface ?? "unknown";
+    bySurface[surface] = (bySurface[surface] ?? 0) + 1;
+    const mode = e.mode ?? "unknown";
+    byMode[mode] = (byMode[mode] ?? 0) + 1;
+    if (reason === "read_unbounded_large") {
+      readBytesWouldBlock += Number(e.fileBytes) || 0;
+    }
+  }
+  return { denials, readBytesWouldBlock, byTool, byReason, bySurface, byMode };
+}
+function runThrottleReport(io, tracePath = THROTTLE_TRACE_PATH) {
   const mode = resolveModeFromEnv();
   if (!(0, import_node_fs11.existsSync)(tracePath)) {
-    io.log(`Scrooge: no trace at ${tracePath} (hook has not compacted anything yet).`);
-    io.log(`Active mode: ${mode} (MMI_SCROOGE env; default conservative).`);
+    io.log(`Throttle: no trace at ${tracePath} (gates have not denied anything yet).`);
+    io.log(`Active mode: ${mode} (MMI_THROTTLE_MODE env; default block).`);
     return 0;
   }
   let raw = "";
   try {
     raw = (0, import_node_fs11.readFileSync)(tracePath, "utf8");
   } catch (e) {
-    io.err(`Scrooge: could not read trace: ${e.message}`);
+    io.err(`Throttle: could not read trace: ${e.message}`);
     return 1;
   }
   const entries = parseTraceLines(raw);
   const s = summarizeTrace(entries);
-  io.log("Scrooge session summary");
+  io.log("Throttle gate summary");
   io.log(`  mode (current env): ${mode}`);
-  io.log(`  compacted tool results: ${s.tools}`);
-  io.log(`  chars in / out: ${s.charsIn} / ${s.charsOut}`);
-  io.log(`  chars saved: ${s.charsSaved}`);
-  io.log(`  est tokens saved (chars/4): ~${s.estTokensSaved}`);
-  const passes = Object.entries(s.passCounts).sort((a, b) => b[1] - a[1]);
-  if (passes.length) {
-    io.log("  passes:");
-    for (const [name, count] of passes) io.log(`    ${name}: ${count}`);
+  io.log(`  trace entries: ${s.denials}`);
+  io.log(`  read bytes would-have-read (fs.stat only): ${s.readBytesWouldBlock}`);
+  io.log("  (Shell denials are not converted to a tokens-saved figure \u2014 counterfactual.)");
+  const modes = Object.entries(s.byMode).sort((a, b) => b[1] - a[1]);
+  if (modes.length) {
+    io.log("  by trace mode (at denial time):");
+    for (const [name, count] of modes) {
+      const label = name === "observe" ? "would-block (observe)" : name === "block" ? "denied (block)" : name;
+      io.log(`    ${label}: ${count}`);
+    }
+  }
+  const tools = Object.entries(s.byTool).sort((a, b) => b[1] - a[1]);
+  if (tools.length) {
+    io.log("  by tool:");
+    for (const [name, count] of tools) io.log(`    ${name}: ${count}`);
+  }
+  const reasons = Object.entries(s.byReason).sort((a, b) => b[1] - a[1]);
+  if (reasons.length) {
+    io.log("  by reason:");
+    for (const [name, count] of reasons) io.log(`    ${name}: ${count}`);
+  }
+  const surfaces = Object.entries(s.bySurface).sort((a, b) => b[1] - a[1]);
+  if (surfaces.length) {
+    io.log("  by surface:");
+    for (const [name, count] of surfaces) io.log(`    ${name}: ${count}`);
   }
   return 0;
 }
-function registerScroogeCommands(program3) {
-  const scrooge = program3.command("scrooge").description("Scrooge \u2014 org tool-output compaction (trace + report)");
-  scrooge.command("report").description("print char/token savings from .mmi/scrooge/trace.jsonl").action(() => {
-    const code = runScroogeReport({ log: (s) => console.log(s), err: (s) => console.error(s) });
+function registerThrottleCommands(program3) {
+  const throttle = program3.command("throttle").description("Scrooge v2 \u2014 tool-economy gate trace + report");
+  throttle.command("report").description("print gate denial stats from .mmi/throttle/trace.jsonl").action(() => {
+    const code = runThrottleReport({ log: (s) => console.log(s), err: (s) => console.error(s) });
     process.exit(code);
   });
 }
@@ -8378,7 +8443,7 @@ var MANAGED_GITIGNORE_LINES = [
   // .mmi is agent/CI scratch — ignore the WHOLE tree at any depth (root + cli/.mmi, .github/workflows/.mmi,
   // and any future feature's subdir) so new scratch NEVER needs a new ignore line. `**/.mmi/*` ignores the
   // dir's contents (not the dir itself), so the one tracked file is re-included on the next line (#1550).
-  // This replaces the brittle per-path enumeration (saga/honcho/head-ts/scrooge/… — #1472 was one such miss).
+  // This replaces the brittle per-path enumeration (saga/honcho/head-ts/throttle/… — #1472 was one such miss).
   "**/.mmi/*",
   // The single tracked .mmi file. A NEW tracked .mmi file would add its own `!` line here; everything else
   // under .mmi stays ignored automatically.
@@ -8495,10 +8560,16 @@ function resolveBootstrapReleaseTrack(cls, explicit) {
   if (cls === "content") return "trunk";
   return "full";
 }
-function resolveReleaseTrack(meta, hints) {
+function metaIsHubControlRepo(meta, repo) {
+  if (repo && repoIsHub(repo)) return true;
+  const repos = meta?.repos;
+  return Array.isArray(repos) && repos.some((r) => typeof r === "string" && repoIsHub(r));
+}
+function resolveReleaseTrack(meta, hints, repo) {
   const raw = typeof meta?.releaseTrack === "string" ? meta.releaseTrack : void 0;
   if (isReleaseTrack(raw)) return raw;
   if (meta?.class === "content" || meta?.deployModel === "content") return "trunk";
+  if (metaIsHubControlRepo(meta, repo)) return "direct";
   const inferred = hints ? inferReleaseTrackFromBranches(hints) : void 0;
   if (inferred) return inferred;
   return "full";
@@ -8865,6 +8936,14 @@ async function contentExists(deps, repo, branch, path2) {
     return false;
   }
 }
+async function branchPresence(deps, repo, branch) {
+  try {
+    await deps.client.rest("GET", `repos/${repo}/branches/${encodeURIComponent(branch)}`);
+    return true;
+  } catch (e) {
+    return e?.status === 404 ? false : void 0;
+  }
+}
 function collectRegistryRepos(projects) {
   const seen = /* @__PURE__ */ new Set();
   for (const project2 of projects) {
@@ -8873,7 +8952,7 @@ function collectRegistryRepos(projects) {
       seen.add(repo);
     }
   }
-  if (!seen.has(HUB_REPO)) seen.add(HUB_REPO);
+  if (![...seen].some((r) => r.toLowerCase() === HUB_REPO.toLowerCase())) seen.add(HUB_REPO);
   return [...seen].sort((a, b) => a.localeCompare(b));
 }
 async function resolveRepoMergeCiPolicy(repo, deps) {
@@ -8898,6 +8977,10 @@ async function auditRepoCi(repo, deps) {
   const meta = await deps.getProjectMeta(slugFromRepo(repo));
   const repoClass = classifyRepo(repo, meta);
   const checks = [];
+  const registryCi = meta?.ci;
+  const registryRequiredChecks = meta?.requiredChecks;
+  const explicitNoCi = registryCi === "none" || registryRequiredChecks === null || Array.isArray(registryRequiredChecks) && registryRequiredChecks.length === 0;
+  const deployableGated = repoClass === "deployable" && !explicitNoCi;
   const info = await restJson(deps, `repos/${repo}`, {});
   const baseBranch = repoClass === "content" ? "main" : "development";
   checks.push({
@@ -8917,7 +9000,7 @@ async function auditRepoCi(repo, deps) {
     detail: info.delete_branch_on_merge === true ? void 0 : "false or unavailable"
   });
   const hasGateWorkflow = repoClass === "hub" ? true : repoClass === "content" ? true : await contentExists(deps, repo, baseBranch, PRODUCT_GATE_PATH);
-  if (repoClass === "deployable") {
+  if (deployableGated) {
     checks.push({
       ok: hasGateWorkflow,
       label: "gate workflow committed",
@@ -8942,7 +9025,7 @@ async function auditRepoCi(repo, deps) {
       label: "Hub required status checks active",
       detail: missing.length ? `missing: ${missing.join(", ")}` : void 0
     });
-  } else if (repoClass === "deployable") {
+  } else if (deployableGated) {
     const missing = [PRODUCT_GATE_CONTEXT2].filter((c) => !statusChecks.has(c));
     checks.push({
       ok: missing.length === 0,
@@ -8951,29 +9034,42 @@ async function auditRepoCi(repo, deps) {
       remediation: missing.length ? `Import ${PRODUCT_RULESET_REF} as an active repository ruleset (GitHub \u2192 Settings \u2192 Rules \u2192 Rulesets) \u2014 target: bootstrap --apply automation (#1440)` : void 0
     });
   }
-  const registryCi = meta?.ci;
-  const registryRequiredChecks = meta?.requiredChecks;
   const workflowPaths = hasGateWorkflow && repoClass === "deployable" ? [PRODUCT_GATE_PATH] : [];
   const { policy, reason } = resolveMergeCiPolicy({
     workflowPaths,
     registryCi,
     registryRequiredChecks
   });
-  if (repoClass === "content") {
-    const explicitNoCi = registryCi === "none" || registryRequiredChecks === null || Array.isArray(registryRequiredChecks) && registryRequiredChecks.length === 0;
+  if (repoClass === "content" || repoClass === "deployable" && explicitNoCi) {
     checks.push({
       ok: explicitNoCi,
       label: "registry META declares intentional no-ci",
       detail: explicitNoCi ? void 0 : "set ci:none and requiredChecks:[] in registry META",
       remediation: `mmi-cli project set ${repo} --var ci=none --var requiredChecks=[]`
     });
-  } else if (repoClass === "deployable") {
+  } else if (deployableGated) {
     checks.push({
       ok: policy === "wait-for-checks",
       label: "merge CI policy is wait-for-checks",
       detail: `${policy} (${reason})`
     });
   }
+  if (repoClass === "deployable") {
+    const effectiveTrack = resolveReleaseTrack(meta, void 0, repo);
+    if (effectiveTrack === "full" || effectiveTrack === "direct") {
+      const rcPresent = await branchPresence(deps, repo, "rc");
+      if (rcPresent !== void 0) {
+        const trackExpectsRc = effectiveTrack === "full";
+        const wantTrack = rcPresent ? "full" : "direct";
+        checks.push({
+          ok: trackExpectsRc === rcPresent,
+          label: "release track matches branch topology",
+          detail: trackExpectsRc === rcPresent ? void 0 : `registry resolves '${effectiveTrack}' but the rc branch ${rcPresent ? "exists" : "is absent"} \u2014 set release track '${wantTrack}'`,
+          remediation: trackExpectsRc === rcPresent ? void 0 : `mmi-cli project set ${repo} --release-track ${wantTrack}`
+        });
+      }
+    }
+  }
   const ok = checks.every((c) => c.ok);
   return { repo, class: repoClass, mergePolicy: policy, ok, checks };
 }
@@ -9082,7 +9178,12 @@ async function putSeedFile(deps, repo, path2, content, branch) {
 }
 async function seedGateYml(repo, deps, meta, result) {
   const baseBranch = "development";
-  if (await contentExists(deps, repo, baseBranch, PRODUCT_GATE_PATH)) return;
+  const releaseTrack = isReleaseTrack(meta?.releaseTrack) ? meta?.releaseTrack : void 0;
+  const parsed = parseOwnerRepo(repo);
+  if (await contentExists(deps, repo, baseBranch, PRODUCT_GATE_PATH)) {
+    await seedRulesetRefIfMissing(repo, deps, withDerivedRepoVars({ REPO_SLUG: parsed.slug }, parsed, "deployable", releaseTrack), baseBranch, result);
+    return;
+  }
   if (!deps.readSeedFile && !deps.renderSeed) {
     result.skipped.push(`gate.yml missing but no seed-template source wired \u2014 run bootstrap apply`);
     return;
@@ -9092,8 +9193,6 @@ async function seedGateYml(repo, deps, meta, result) {
     result.skipped.push(`gate.yml missing \u2014 no registry gate config; set \`mmi-cli project set ${repo} --var gate={...}\` first, then re-run reconcile`);
     return;
   }
-  const releaseTrack = isReleaseTrack(meta?.releaseTrack) ? meta?.releaseTrack : void 0;
-  const parsed = parseOwnerRepo(repo);
   const derivedVars = withDerivedRepoVars({ ...gateConfigToVars(gate), REPO_SLUG: parsed.slug }, parsed, "deployable", releaseTrack);
   const rendered = renderSeedBody(deps, GATE_TEMPLATE_SEED, PRODUCT_GATE_PATH, derivedVars);
   if (rendered == null) {
@@ -9107,16 +9206,18 @@ async function seedGateYml(repo, deps, meta, result) {
     result.errors.push(`gate.yml re-seed failed: ${e.message}`);
     return;
   }
-  if (!await contentExists(deps, repo, baseBranch, PRODUCT_RULESET_REF)) {
-    const rulesetBody = renderSeedBody(deps, RULESET_TEMPLATE_SEED, PRODUCT_RULESET_REF, derivedVars);
-    if (rulesetBody != null) {
-      try {
-        await putSeedFile(deps, repo, PRODUCT_RULESET_REF, rulesetBody, baseBranch);
-        result.applied.push(`seeded ${PRODUCT_RULESET_REF}`);
-      } catch (e) {
-        result.errors.push(`ruleset reference re-seed failed: ${e.message}`);
-      }
-    }
+  await seedRulesetRefIfMissing(repo, deps, derivedVars, baseBranch, result);
+}
+async function seedRulesetRefIfMissing(repo, deps, derivedVars, baseBranch, result) {
+  if (await contentExists(deps, repo, baseBranch, PRODUCT_RULESET_REF)) return;
+  if (!deps.readSeedFile && !deps.renderSeed) return;
+  const rulesetBody = renderSeedBody(deps, RULESET_TEMPLATE_SEED, PRODUCT_RULESET_REF, derivedVars);
+  if (rulesetBody == null) return;
+  try {
+    await putSeedFile(deps, repo, PRODUCT_RULESET_REF, rulesetBody, baseBranch);
+    result.applied.push(`seeded ${PRODUCT_RULESET_REF}`);
+  } catch (e) {
+    result.errors.push(`ruleset reference seed failed: ${e.message}`);
   }
 }
 async function applyCiReconcileRepo(repo, deps) {
@@ -11849,7 +11950,8 @@ var ORG_SPINE_FILES = [
   "GEMINI.md",
   ".claude/settings.json",
   ".claude/output-styles/mmi-plain.md",
-  ".cursor/rules/mmi-plain-language.mdc"
+  ".cursor/rules/mmi-plain-language.mdc",
+  ".cursor/rules/mmi-tool-economy.mdc"
 ];
 function isSpinePath(path2) {
   return ORG_SPINE_FILES.includes(path2);
@@ -15930,7 +16032,8 @@ async function runRulesSync(opts, io = consoleIo) {
     "CLAUDE.md",
     ".claude/settings.json",
     ".claude/output-styles/mmi-plain.md",
-    ".cursor/rules/mmi-plain-language.mdc"
+    ".cursor/rules/mmi-plain-language.mdc",
+    ".cursor/rules/mmi-tool-economy.mdc"
   ];
   const fetched = await Promise.all(files.map(async (file) => {
     try {
@@ -15992,7 +16095,7 @@ docs.command("sync").option("--quiet", "stay silent unless something changed or
 registerSagaCommands(program2);
 registerHandoffCommands(program2);
 registerHonchoCommands(program2);
-registerScroogeCommands(program2);
+registerThrottleCommands(program2);
 program2.command("commands").description("print the command manifest \u2014 every subcommand + its flags (ground against this instead of guessing)").option("--json", "machine-readable JSON: { name, version, tree, index } \u2014 index is a flat list of every leaf command path").action((o) => {
   const manifest = buildCommandManifest(program2);
   consoleIo.log(o.json ? JSON.stringify(manifest, null, 2) : formatManifestHuman(manifest));
@@ -16711,7 +16814,7 @@ project.command("get [owner/repo]").description("a project's META (board ids + p
   console.log(JSON.stringify(read.project));
   if (!o.json) {
     const m = read.project;
-    const track = resolveReleaseTrack(m);
+    const track = resolveReleaseTrack(m, void 0, target);
     const stages = branchesForTrack(track).join(" -> ");
     const note = track === "direct" ? " (direct \u2014 no rc; /rcand refuses, /release ships development -> main)" : track === "trunk" ? " (trunk \u2014 main only)" : "";
     console.error(

package/dist/saga.cjs

@@ -4370,19 +4370,54 @@ var injectedStdin;
 function setInjectedStdin(payload) {
   injectedStdin = payload;
 }
-function stdinHasPipedInput(statFd = () => (0, import_node_fs6.fstatSync)(0)) {
+function stdinHasPipedInput(statFd = () => (0, import_node_fs6.fstatSync)(0), getIsTTY = () => process.stdin.isTTY) {
   try {
     const stat = statFd();
-    return stat.isFIFO() || stat.isFile();
+    if (stat.isFIFO() || stat.isFile()) return true;
+    if (stat.isCharacterDevice()) return false;
+    if (stat.isSocket()) return false;
+    if (getIsTTY() === true) return false;
+    return true;
   } catch {
     return false;
   }
 }
-async function readStdin() {
+var STDIN_MAX_BYTES = 8 * 1024 * 1024;
+var STDIN_DRAIN_TIMEOUT_MS = 5e3;
+async function readStdin(opts = {}) {
   if (injectedStdin !== void 0) return injectedStdin;
   if (!stdinHasPipedInput()) return "";
+  const maxBytes = opts.maxBytes ?? STDIN_MAX_BYTES;
+  const timeoutMs = opts.timeoutMs ?? STDIN_DRAIN_TIMEOUT_MS;
   const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
+  let total = 0;
+  const drain = (async () => {
+    for await (const chunk of process.stdin) {
+      const buf = chunk;
+      const room = maxBytes - total;
+      if (buf.length >= room) {
+        chunks.push(buf.subarray(0, room));
+        total = maxBytes;
+        break;
+      }
+      chunks.push(buf);
+      total += buf.length;
+    }
+  })().catch(() => {
+  });
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeoutMs);
+  });
+  try {
+    await Promise.race([drain, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    try {
+      process.stdin.unref();
+    } catch {
+    }
+  }
   return Buffer.concat(chunks).toString("utf8");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "2.37.0",
+  "version": "2.38.1",
   "description": "MMI Future CLI — delivers the org rules (whole-file), plus saga and KB access. The cross-IDE engine the plugin's SessionStart hook drives.",
   "type": "module",
   "license": "UNLICENSED",