@wairon/cli 5.1.1-dev.57 → 5.1.1-dev.58

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.57";
+    WAIRON_VERSION = "5.1.1-dev.58";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -546,6 +546,21 @@ var init_yaml = __esm({
 });
 
 // src/models/execution.ts
+function summarize(budget, profile) {
+  const lines = [
+    `- **Work shape**: ${profile.breadth} breadth, ${profile.reasoningDepth} reasoning${profile.writes ? "" : ", read-only"}${profile.delegates ? ", delegating" : ""}`,
+    `- **Why**: ${profile.rationale}`
+  ];
+  if (budget.modelTier) lines.push(`- **Capability tier**: ${budget.modelTier}`);
+  if (budget.effort) lines.push(`- **Effort**: ${budget.effort}`);
+  if (budget.maxTurns !== void 0) {
+    lines.push(`- **Turn ceiling**: ${budget.maxTurns} (a circuit breaker \u2014 hitting it should read as a scoping error, not a limit to work up to)`);
+  }
+  lines.push(`- **Tool grant**: ${budget.toolClass}`);
+  lines.push(`- **May delegate further**: ${budget.allowNestedDelegation ? "yes" : "no"}`);
+  lines.push(`- **MCP access**: ${budget.mcp}`);
+  return lines;
+}
 var import_zod, WorkBreadthSchema, ReasoningDepthSchema, ExecutionProfileSchema, ModelTierSchema, EffortTierSchema, ToolClassSchema, McpAccessSchema, ExecutionBudgetSchema, BudgetTierSchema, BUDGET_TIER_DESCRIPTIONS, ExecutionConfigSchema;
 var init_execution = __esm({
   "src/models/execution.ts"() {
@@ -14256,12 +14271,109 @@ var init_carried_debt = __esm({
   }
 });
 
+// src/core/rules/heuristic/method-cohesion.ts
+function groupsSharingCollaborators(calledBy) {
+  const parent = /* @__PURE__ */ new Map();
+  const find = (m) => {
+    let root = m;
+    while (parent.get(root) !== root) root = parent.get(root);
+    return root;
+  };
+  const union = (a, b) => {
+    const [ra, rb] = [find(a), find(b)];
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  const methods = [...calledBy.keys()];
+  for (const m of methods) parent.set(m, m);
+  for (let i = 0; i < methods.length; i++) {
+    for (let j = i + 1; j < methods.length; j++) {
+      const shares = [...calledBy.get(methods[i])].some((c) => calledBy.get(methods[j])?.has(c));
+      if (shares) union(methods[i], methods[j]);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const m of methods) {
+    const root = find(m);
+    groups.set(root, [...groups.get(root) ?? [], m]);
+  }
+  return [...groups.values()];
+}
+function isForwardingMethod(narrative) {
+  let handoffs = 0;
+  for (const step of narrative) {
+    if (step.type === "call" || step.type === "dispatch") handoffs++;
+    else if (step.type !== "return") return false;
+  }
+  return handoffs === 1;
+}
+function isPureForwarder(methods) {
+  const narrated = methods.filter((m) => (m.narrative ?? []).length > 0);
+  return narrated.length > 0 && narrated.every((m) => isForwardingMethod(m.narrative ?? []));
+}
+function pureForwarderComponents(ctx) {
+  const realized = /* @__PURE__ */ new Map();
+  for (const impl of ctx.implementations) {
+    const intf = ctx.interfaceMap.get(impl.contract);
+    if (!intf) continue;
+    realized.set(intf.component, [...realized.get(intf.component) ?? [], ...impl.methods]);
+  }
+  return new Set([...realized].filter(([, methods]) => isPureForwarder(methods)).map(([id]) => id));
+}
+var methodCohesionRule;
+var init_method_cohesion = __esm({
+  "src/core/rules/heuristic/method-cohesion.ts"() {
+    "use strict";
+    methodCohesionRule = {
+      name: "method-cohesion",
+      description: "An Orchestrator's methods share collaborators; when they split into groups that call no component in common, the component holds more than one responsibility. Reported only where two or more groups each hold two or more methods, so a single specialized method is not a finding \u2014 and never on a pure forwarder, whose every narrated method is a single hand-off and whose responsibility therefore lives in what it forwards to.",
+      codes: [
+        { code: "INCOHESIVE_METHODS", defaultSeverity: "warning", summary: "Orchestrator's methods form two or more groups of two or more that share no called component" }
+      ],
+      check(ctx) {
+        const subjects = [];
+        for (const impl of ctx.implementations) {
+          const intf = ctx.interfaceMap.get(impl.contract);
+          const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
+          if (!comp || comp.componentType !== "Orchestrator") continue;
+          if (isPureForwarder(impl.methods)) continue;
+          const calledBy = /* @__PURE__ */ new Map();
+          for (const method2 of impl.methods) {
+            const reached = /* @__PURE__ */ new Set();
+            for (const step of method2.narrative ?? []) {
+              if ((step.type === "call" || step.type === "dispatch") && step.targetComponent) reached.add(step.targetComponent);
+            }
+            if (reached.size > 0) calledBy.set(method2.name, reached);
+          }
+          subjects.push({ implementation: impl, component: comp, calledBy });
+        }
+        for (const { component, calledBy } of subjects) {
+          if (calledBy.size < 2) continue;
+          const groups = groupsSharingCollaborators(calledBy).filter((g) => g.length >= 2);
+          if (groups.length < 2) continue;
+          const described = groups.map((g) => {
+            const collaborators = [...new Set(g.flatMap((m) => [...calledBy.get(m)]))].sort();
+            return `${g.join(", ")} (calling ${collaborators.join(", ")})`;
+          }).join("; ");
+          ctx.addIssue(
+            "warning",
+            "INCOHESIVE_METHODS",
+            `Orchestrator "${component.id}" holds ${groups.length} groups of methods that share no called component: ${described}. Split it along those groups, move the logic out until every method is a single hand-off (a pure forwarder is exempt), or acknowledge a deliberate facade with a reasoned lint.allow for INCOHESIVE_METHODS.`,
+            component.id,
+            ctx.isComponentDraft(component.id)
+          );
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/heuristic/coupling-health.ts
 var DEFAULT_GOD_COMPONENT_THRESHOLD, couplingRule;
 var init_coupling_health = __esm({
   "src/core/rules/heuristic/coupling-health.ts"() {
     "use strict";
     init_models();
+    init_method_cohesion();
     DEFAULT_GOD_COMPONENT_THRESHOLD = 8;
     couplingRule = {
       name: "coupling-health",
@@ -14270,7 +14382,7 @@ var init_coupling_health = __esm({
         { code: "MUTUAL_SUBSYSTEM_DEPENDENCY", defaultSeverity: "warning", summary: "Subsystems depend on each other without a declared trusted link" },
         { code: "INVALID_TRUSTED_LINK", defaultSeverity: "error", summary: "trustedLinks references a non-existent subsystem" },
         { code: "UNUSED_TRUSTED_LINK", defaultSeverity: "warning", summary: "trustedLinks declares a peer no dependency actually reaches" },
-        { code: "GOD_COMPONENT", defaultSeverity: "warning", summary: "Component with excessive dependency fan-out" }
+        { code: "GOD_COMPONENT", defaultSeverity: "warning", summary: "Component with excessive dependency fan-out; not reported on a pure forwarder, whose every narrated method is a single hand-off" }
       ],
       check(ctx) {
         const subsystemDeps = /* @__PURE__ */ new Map();
@@ -14342,9 +14454,10 @@ var init_coupling_health = __esm({
             );
           }
         }
+        const forwarders = pureForwarderComponents(ctx);
         for (const comp of ctx.components) {
           const threshold = ctx.complexityConfigFor(comp.subsystem)?.maxComponentDependencies ?? DEFAULT_GOD_COMPONENT_THRESHOLD;
-          if (comp.dependsOn.length > threshold) {
+          if (comp.dependsOn.length > threshold && !forwarders.has(comp.id)) {
             ctx.addIssue(
               "warning",
               "GOD_COMPONENT",
@@ -14968,6 +15081,7 @@ var init_complexity_and_metadata = __esm({
   "src/core/rules/heuristic/complexity-and-metadata.ts"() {
     "use strict";
     init_models();
+    init_method_cohesion();
     complexityRule = {
       name: "complexity-and-metadata",
       description: "Enforces metadata documentation completeness (checking if descriptions are missing or too short) and structural complexity caps (limits on methods per interface, parameters per method, dependencies per component, and components per subsystem) configured globally or in architectural profiles. A narrative's own length and shape are judged by narrative-complexity.",
@@ -14976,7 +15090,7 @@ var init_complexity_and_metadata = __esm({
         { code: "DESCRIPTION_TOO_SHORT", defaultSeverity: "warning", summary: "Description is shorter than the configured minimum length" },
         { code: "EXCESSIVE_METHODS", defaultSeverity: "warning", summary: "Interface declares more methods than the configured limit" },
         { code: "EXCESSIVE_METHOD_PARAMS", defaultSeverity: "warning", summary: "Interface method declares more parameters than the configured limit" },
-        { code: "EXCESSIVE_DEPENDENCIES", defaultSeverity: "warning", summary: "Component has more dependencies than the configured limit" },
+        { code: "EXCESSIVE_DEPENDENCIES", defaultSeverity: "warning", summary: "Component has more dependencies than the configured limit; not reported on a pure forwarder, whose fan-out is a routing table rather than knowledge" },
         { code: "EXCESSIVE_SUBSYSTEM_COMPONENTS", defaultSeverity: "warning", summary: "Subsystem has more direct components than the configured limit" }
       ],
       check(ctx) {
@@ -14996,6 +15110,7 @@ var init_complexity_and_metadata = __esm({
             );
           }
         }
+        const forwarders = pureForwarderComponents(ctx);
         for (const comp of ctx.components) {
           const docConfig = ctx.documentationConfigFor(comp.subsystem);
           const complexityConfig = ctx.complexityConfigFor(comp.subsystem);
@@ -15009,7 +15124,7 @@ var init_complexity_and_metadata = __esm({
             "Component",
             isDraft
           );
-          if (complexityConfig?.maxComponentDependencies !== void 0 && comp.dependsOn.length > complexityConfig.maxComponentDependencies) {
+          if (complexityConfig?.maxComponentDependencies !== void 0 && comp.dependsOn.length > complexityConfig.maxComponentDependencies && !forwarders.has(comp.id)) {
             ctx.addIssue(
               "warning",
               "EXCESSIVE_DEPENDENCIES",
@@ -15308,90 +15423,6 @@ var init_naming_discipline = __esm({
   }
 });
 
-// src/core/rules/heuristic/method-cohesion.ts
-function groupsSharingCollaborators(calledBy) {
-  const parent = /* @__PURE__ */ new Map();
-  const find = (m) => {
-    let root = m;
-    while (parent.get(root) !== root) root = parent.get(root);
-    return root;
-  };
-  const union = (a, b) => {
-    const [ra, rb] = [find(a), find(b)];
-    if (ra !== rb) parent.set(ra, rb);
-  };
-  const methods = [...calledBy.keys()];
-  for (const m of methods) parent.set(m, m);
-  for (let i = 0; i < methods.length; i++) {
-    for (let j = i + 1; j < methods.length; j++) {
-      const shares = [...calledBy.get(methods[i])].some((c) => calledBy.get(methods[j])?.has(c));
-      if (shares) union(methods[i], methods[j]);
-    }
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (const m of methods) {
-    const root = find(m);
-    groups.set(root, [...groups.get(root) ?? [], m]);
-  }
-  return [...groups.values()];
-}
-function isForwardingMethod(narrative) {
-  let handoffs = 0;
-  for (const step of narrative) {
-    if (step.type === "call" || step.type === "dispatch") handoffs++;
-    else if (step.type !== "return") return false;
-  }
-  return handoffs === 1;
-}
-var methodCohesionRule;
-var init_method_cohesion = __esm({
-  "src/core/rules/heuristic/method-cohesion.ts"() {
-    "use strict";
-    methodCohesionRule = {
-      name: "method-cohesion",
-      description: "An Orchestrator's methods share collaborators; when they split into groups that call no component in common, the component holds more than one responsibility. Reported only where two or more groups each hold two or more methods, so a single specialized method is not a finding \u2014 and never on a pure forwarder, whose every narrated method is a single hand-off and whose responsibility therefore lives in what it forwards to.",
-      codes: [
-        { code: "INCOHESIVE_METHODS", defaultSeverity: "warning", summary: "Orchestrator's methods form two or more groups of two or more that share no called component" }
-      ],
-      check(ctx) {
-        const subjects = [];
-        for (const impl of ctx.implementations) {
-          const intf = ctx.interfaceMap.get(impl.contract);
-          const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
-          if (!comp || comp.componentType !== "Orchestrator") continue;
-          const narrated = impl.methods.filter((m) => (m.narrative ?? []).length > 0);
-          if (narrated.length > 0 && narrated.every((m) => isForwardingMethod(m.narrative ?? []))) continue;
-          const calledBy = /* @__PURE__ */ new Map();
-          for (const method2 of impl.methods) {
-            const reached = /* @__PURE__ */ new Set();
-            for (const step of method2.narrative ?? []) {
-              if ((step.type === "call" || step.type === "dispatch") && step.targetComponent) reached.add(step.targetComponent);
-            }
-            if (reached.size > 0) calledBy.set(method2.name, reached);
-          }
-          subjects.push({ implementation: impl, component: comp, calledBy });
-        }
-        for (const { component, calledBy } of subjects) {
-          if (calledBy.size < 2) continue;
-          const groups = groupsSharingCollaborators(calledBy).filter((g) => g.length >= 2);
-          if (groups.length < 2) continue;
-          const described = groups.map((g) => {
-            const collaborators = [...new Set(g.flatMap((m) => [...calledBy.get(m)]))].sort();
-            return `${g.join(", ")} (calling ${collaborators.join(", ")})`;
-          }).join("; ");
-          ctx.addIssue(
-            "warning",
-            "INCOHESIVE_METHODS",
-            `Orchestrator "${component.id}" holds ${groups.length} groups of methods that share no called component: ${described}. Split it along those groups, move the logic out until every method is a single hand-off (a pure forwarder is exempt), or acknowledge a deliberate facade with a reasoned lint.allow for INCOHESIVE_METHODS.`,
-            component.id,
-            ctx.isComponentDraft(component.id)
-          );
-        }
-      }
-    };
-  }
-});
-
 // src/core/rules/repository.ts
 function addRule(rule) {
   ruleSet.push(rule);
@@ -23251,21 +23282,6 @@ function resolveBudget(profile, config, agentId) {
   const override = config.overrides[agentId];
   return override ? { ...budget, ...override } : budget;
 }
-function describeBudget(profile, budget) {
-  const lines = [
-    `- **Work shape**: ${profile.breadth} breadth, ${profile.reasoningDepth} reasoning${profile.writes ? "" : ", read-only"}${profile.delegates ? ", delegating" : ""}`,
-    `- **Why**: ${profile.rationale}`
-  ];
-  if (budget.modelTier) lines.push(`- **Capability tier**: ${budget.modelTier}`);
-  if (budget.effort) lines.push(`- **Effort**: ${budget.effort}`);
-  if (budget.maxTurns !== void 0) {
-    lines.push(`- **Turn ceiling**: ${budget.maxTurns} (a circuit breaker \u2014 hitting it should read as a scoping error, not a limit to work up to)`);
-  }
-  lines.push(`- **Tool grant**: ${budget.toolClass}`);
-  lines.push(`- **May delegate further**: ${budget.allowNestedDelegation ? "yes" : "no"}`);
-  lines.push(`- **MCP access**: ${budget.mcp}`);
-  return lines;
-}
 var TIER_ORDER, TIER_STEPS;
 var init_budget_policy = __esm({
   "src/core/budget_policy.ts"() {
@@ -23406,7 +23422,7 @@ function inferSourcePathForComponent(comp, subsystems) {
     return null;
   }
 }
-function summarize(text2, max = 140) {
+function summarize2(text2, max = 140) {
   const clean = text2.replace(/\s+/g, " ").trim();
   const period = clean.indexOf(". ");
   const firstSentence = period > 0 ? clean.slice(0, period + 1) : clean;
@@ -23433,7 +23449,7 @@ function resolveAgentTopology() {
   agents.push({
     id: "system-architect",
     name: `${system.name} Architect`,
-    description: `Global architect for ${system.name} \u2014 owns the spec tree and topology. ${summarize(system.vision)}`,
+    description: `Global architect for ${system.name} \u2014 owns the spec tree and topology. ${summarize2(system.vision)}`,
     template: "architect",
     creationReason: "Automatically inferred from L0 system spec",
     ownedPaths: [".wai/specs/**"],
@@ -23513,7 +23529,7 @@ function resolveAgentTopology() {
     agents.push({
       id: `${sub.id}-owner`,
       name: `${sub.name} Owner`,
-      description: `Owns the ${sub.id} subsystem. ${summarize(sub.description)}`,
+      description: `Owns the ${sub.id} subsystem. ${summarize2(sub.description)}`,
       template: "domain-owner",
       creationReason: `Automatically inferred from L1 subsystem spec: ${sub.id}`,
       domainRoot: sub.id,
@@ -23578,7 +23594,7 @@ function resolveAgentTopology() {
     agents.push({
       id: `${dom.id}-owner`,
       name: `${dom.name ?? dom.id} Owner`,
-      description: dom.description ? summarize(dom.description) : `Owner agent for the free-standing "${dom.id}" domain.`,
+      description: dom.description ? summarize2(dom.description) : `Owner agent for the free-standing "${dom.id}" domain.`,
       template: "domain-owner",
       creationReason: "Inferred from a free-standing domain in .wai/topology.yaml",
       domainRoot: dom.id,
@@ -28257,6 +28273,8 @@ var init_core = __esm({
     init_approver();
     init_specs2();
     init_project_config();
+    init_execution_profile();
+    init_budget_policy();
   }
 });
 
@@ -28958,7 +28976,7 @@ function renderAgentBriefMarkdown(brief) {
       "",
       "## Execution budget",
       "",
-      ...describeBudget(brief.profile, brief.budget),
+      ...summarize(brief.budget, brief.profile),
       "",
       "Advisory \u2014 apply these when spawning. Map the capability tier onto your host tool's models; a tool that cannot express a field should ignore it rather than approximate it."
     );
@@ -30346,7 +30364,7 @@ var init_server = __esm({
     init_variants();
     init_agent_resolver();
     init_core();
-    init_budget_policy();
+    init_execution();
     init_surfaces();
     TYPE_REF_GRAMMAR = (what) => `${what}: a primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice" or "billing::Invoice"). Generics, arrays and UNIONS are all read, at any depth: "Invoice | null" (the commonest shape there is), "Invoice | undefined", "Invoice | Receipt", "Promise<Invoice | null>", "Map<string, Invoice | null>", "Invoice[] | null", "(Invoice | null)[]". Every identifier the string names must resolve \u2014 a union of two defined types means BOTH must exist. A union of string literals ("read" | "write") names no type and resolves to nothing.`;
     staleServerOutput = {
@@ -31116,6 +31134,12 @@ function removeDomain2(id) {
 function detectDomainCandidates2(projectRoot2, trackedPaths, trackedIds) {
   return detectDomainCandidates(projectRoot2, trackedPaths, trackedIds);
 }
+function deriveExecutionProfile2(agent) {
+  return deriveExecutionProfile(agent);
+}
+function resolveBudget2(profile, config, agentId) {
+  return resolveBudget(profile, config, agentId);
+}
 async function runSubsystemAdd(id, options = {}) {
   logger.header("wairon subsystem add");
   if (!projectConfigExists2()) {
@@ -48372,15 +48396,12 @@ function report(outcome) {
 }
 
 // src/cli/index.ts
-init_budget_policy();
+init_execution();
 
 // src/commands/execution.ts
 var import_chalk21 = __toESM(require("chalk"));
 init_logger();
 init_errors();
-init_agent_resolver();
-init_execution_profile();
-init_budget_policy();
 init_execution();
 function assertInitialized() {
   if (!projectConfigExists2()) {
@@ -48408,7 +48429,7 @@ async function showExecution() {
     logger.info(`Enable with ${import_chalk21.default.bold("wairon execution set-tier default")}.`);
     return;
   }
-  const agents = resolveAgentTopology();
+  const agents = resolveAgentTopology2();
   if (agents.length === 0) {
     logger.blank();
     logger.warn("No agents in the topology yet \u2014 nothing to budget.");
@@ -48416,8 +48437,8 @@ async function showExecution() {
   }
   logger.blank();
   const rows = agents.map((agent) => {
-    const profile = deriveExecutionProfile(agent);
-    const budget = resolveBudget(profile, config.execution, agent.id);
+    const profile = deriveExecutionProfile2(agent);
+    const budget = resolveBudget2(profile, config.execution, agent.id);
     return { agent, profile, budget };
   });
   const idWidth = Math.max(...rows.map((r) => r.agent.id.length));
@@ -48752,7 +48773,7 @@ async function runAgent(action, id) {
       if (brief.budget && brief.profile) {
         logger.blank();
         logger.info("Execution budget (advisory \u2014 apply when spawning):");
-        for (const line2 of describeBudget(brief.profile, brief.budget)) {
+        for (const line2 of summarize(brief.budget, brief.profile)) {
           logger.info(`  ${line2.replace(/^- \*\*(.+?)\*\*: /, "$1: ")}`);
         }
       }