@wairon/cli 5.1.1-dev.45 → 5.1.1-dev.46

package/dist/index.js

@@ -1222,7 +1222,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.45";
+    WAIRON_VERSION = "5.1.1-dev.46";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -2230,8 +2230,12 @@ var init_specs = __esm({
        * so a lower detail dial no longer vouches for everything the component
        * declares. Each entry gets the same target validation a `call` step gets
        * (the component resolves, the caller declares it, the method is on its
-       * contract). Refused beside a non-empty narrative, where the steps already
-       * say what is called and a second spelling could only disagree.
+       * contract) AND the same code↔spec reading (call-conformance, both
+       * directions): an entry asserts the same call a step does, minus the
+       * position in the flow that check never reads, so it can no more buy
+       * reachability without the code than a step can. Refused beside a non-empty
+       * narrative, where the steps already say what is called and a second
+       * spelling could only disagree.
        */
       calls: import_zod8.z.array(import_zod8.z.string().min(1)).optional(),
       /**
@@ -13559,6 +13563,18 @@ function resolveCallTarget(ctx, componentId, methodName) {
   }
   return { accepted, files };
 }
+function claimsOf(implMethod) {
+  const claims = [];
+  for (const step of implMethod.narrative) {
+    if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+    claims.push({ step: step.stepNumber, component: step.targetComponent, method: step.targetMethod });
+  }
+  for (const ref of implMethod.calls ?? []) {
+    const parsed = parseDeclaredCall(ref);
+    if (parsed) claims.push({ component: parsed.compId, method: parsed.methodName });
+  }
+  return claims;
+}
 function describeSite(site) {
   if (!site.member) return `${site.name}(\u2026)`;
   if (site.via) return `${site.via}.${site.name}(\u2026)`;
@@ -13567,23 +13583,26 @@ function describeSite(site) {
   return `<receiver>.${site.name}(\u2026)`;
 }
 function describeMiss(m) {
-  const head = `step ${m.step} \u2192 ${m.target} (looked for ${m.accepted.map((a) => `"${a}"`).join(" / ")}`;
+  const where = m.step === void 0 ? "declared call" : `step ${m.step}`;
+  const head = `${where} \u2192 ${m.target} (looked for ${m.accepted.map((a) => `"${a}"`).join(" / ")}`;
   if (m.miss.kind === "elsewhere") return `${head}, called but resolved to ${m.miss.landed.map((p) => `"${p}"`).join(", ")})`;
   if (m.miss.kind === "unresolved") return `${head}, written as ${m.miss.shapes.map((s) => `\`${s}\``).join(" / ")})`;
   return `${head})`;
 }
-var callConformanceRule;
+var unitOf, claimNoun, callConformanceRule;
 var init_call_conformance = __esm({
   "src/core/rules/conformance/call-conformance.ts"() {
     "use strict";
     init_models();
+    unitOf = (m) => m.step === void 0 ? m.target : `${m.step}:${m.target}`;
+    claimNoun = (implMethod) => implMethod.narrative.length ? "narrative call step(s)" : "declared call(s)";
     callConformanceRule = {
       name: "call-conformance",
-      description: "Code\u2194spec Level 3: the narrative `call` step \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. Forward: every `call` step must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a step but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the narrative must declare it (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are skipped, the conformance dial (off) skips, and weaker analysis grades never guess.",
+      description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
       codes: [
-        { code: "CALL_STEP_UNREALIZED", defaultSeverity: "warning", summary: "Narrative call step realized by no call that resolves to the target method's own source file \u2014 the call is absent, or it lands in another module", carryable: true },
-        { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the step was not checked, and is neither proven realized nor accused", carryable: true },
-        { code: "UNDECLARED_COLOCATED_CALL", defaultSeverity: "warning", summary: "The realized function calls a modelled method of another component living in the same source file, and no narrative step declares that call", carryable: true }
+        { code: "CALL_STEP_UNREALIZED", defaultSeverity: "warning", summary: "Narrative call step or declared call realized by no call that resolves to the target method's own source file \u2014 the call is absent, or it lands in another module", carryable: true },
+        { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step or declared call whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the claim was not checked, and is neither proven realized nor accused", carryable: true },
+        { code: "UNDECLARED_COLOCATED_CALL", defaultSeverity: "warning", summary: "The realized function calls a modelled method of another component living in the same source file, and neither a narrative step nor a declared call names it", carryable: true }
       ],
       check(ctx) {
         const code = ctx.codeIndex();
@@ -13600,7 +13619,7 @@ var init_call_conformance = __esm({
           const { implementation: impl, method: implMethod, component, sourceFile: file } = entry;
           const tier = implMethod.conformance ?? impl.conformance ?? defaultConformanceTier(component);
           if (tier === "off") continue;
-          if (!implMethod.narrative.length) continue;
+          if (!implMethod.narrative.length && !implMethod.calls?.length) continue;
           if (!file) continue;
           const facts = code.factsAt(file);
           if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
@@ -13610,16 +13629,15 @@ var init_call_conformance = __esm({
           const sites = closedCallSites(code, file, fnSymbol);
           if (!sites) continue;
           const missed = [];
-          for (const step of implMethod.narrative) {
-            if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
-            if (!ctx.componentMap.has(step.targetComponent)) continue;
-            const target = resolveCallTarget(ctx, step.targetComponent, step.targetMethod);
+          for (const claim of claimsOf(implMethod)) {
+            if (!ctx.componentMap.has(claim.component)) continue;
+            const target = resolveCallTarget(ctx, claim.component, claim.method);
             if (target.accepted.has(fnSymbol)) continue;
             const matching = sites.filter((s) => target.accepted.has(s.name));
-            const ref = `${step.targetComponent}.${step.targetMethod}`;
+            const ref = `${claim.component}.${claim.method}`;
             if (target.files.size === 0) {
               if (matching.length === 0) {
-                missed.push({ step: step.stepNumber, target: ref, accepted: [...target.accepted], miss: { kind: "absent" } });
+                missed.push({ step: claim.step, target: ref, accepted: [...target.accepted], miss: { kind: "absent" } });
               }
               continue;
             }
@@ -13633,7 +13651,7 @@ var init_call_conformance = __esm({
             }
             if (realized) continue;
             const miss = matching.length === 0 ? { kind: "absent" } : landed.size === 0 ? { kind: "unresolved", shapes: [...new Set(matching.map(describeSite))].sort() } : { kind: "elsewhere", landed: [...landed].sort() };
-            missed.push({ step: step.stepNumber, target: ref, accepted: [...target.accepted], miss });
+            missed.push({ step: claim.step, target: ref, accepted: [...target.accepted], miss });
           }
           const unrealized = missed.filter((m) => m.miss.kind !== "unresolved");
           const unresolved = missed.filter((m) => m.miss.kind === "unresolved");
@@ -13641,30 +13659,36 @@ var init_call_conformance = __esm({
             ctx.addIssue(
               "warning",
               "CALL_STEP_UNREALIZED",
-              `Method "${implMethod.name}" in implementation "${impl.id}": ${unrealized.length} narrative call step(s) are realized by no call of the function "${fnSymbol}" in "${file}" that resolves to the target's own source file \u2014 ${unrealized.map(describeMiss).join("; ")}. Callees are closed over the named helpers the function calls, and each call site is resolved through this file's import bindings (order, arguments and conditions are not checked). Realize the calls, fix the narrative, or map code names via per-method symbols on the targets.`,
+              `Method "${implMethod.name}" in implementation "${impl.id}": ${unrealized.length} ${claimNoun(implMethod)} are realized by no call of the function "${fnSymbol}" in "${file}" that resolves to the target's own source file \u2014 ${unrealized.map(describeMiss).join("; ")}. Callees are closed over the named helpers the function calls, and each call site is resolved through this file's import bindings (order, arguments and conditions are not checked). Realize the calls, fix what the method claims, or map code names via per-method symbols on the targets.`,
               impl.id,
               entry.draftContext,
               void 0,
-              // A step, named by its number and its target: what the register
-              // carries is ONE unresolved step, never "this method's call steps".
-              { at: implMethod.name, covers: unrealized.map((m) => `${m.step}:${m.target}`) }
+              // One claim, named the way the register names a unit: a step by its
+              // number and target, a declaration by its target alone. What the
+              // register carries is ONE unrealized claim, never "this method's
+              // calls".
+              { at: implMethod.name, covers: unrealized.map(unitOf) }
             );
           }
           if (unresolved.length) {
             ctx.addIssue(
               "warning",
               "CALL_ORIGIN_UNRESOLVED",
-              `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} narrative call step(s) ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding, a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does. What does not: an import from a PACKAGE specifier, a receiver holding a value the module assembled, a receiver this model records no name for. This reports what was not checked, not what is wrong \u2014 the step is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
+              `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding, a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does. What does not: an import from a PACKAGE specifier, a receiver holding a value the module assembled, a receiver this model records no name for. This reports what was not checked, not what is wrong \u2014 the claim is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
               impl.id,
               entry.draftContext,
               void 0,
-              { at: implMethod.name, covers: unresolved.map((m) => `${m.step}:${m.target}`) }
+              { at: implMethod.name, covers: unresolved.map(unitOf) }
             );
           }
           const declared = /* @__PURE__ */ new Set();
           for (const step of implMethod.narrative) {
             if (step.targetComponent && step.targetMethod) declared.add(`${step.targetComponent}.${step.targetMethod}`);
           }
+          for (const ref of implMethod.calls ?? []) {
+            const parsed = parseDeclaredCall(ref);
+            if (parsed) declared.add(`${parsed.compId}.${parsed.methodName}`);
+          }
           const crossings = /* @__PURE__ */ new Map();
           for (const site of closedCallSites(code, file, fnSymbol, new Set(colocated.keys())) ?? []) {
             const owner = colocated.get(site.name);
@@ -13679,7 +13703,7 @@ var init_call_conformance = __esm({
             ctx.addIssue(
               "warning",
               "UNDECLARED_COLOCATED_CALL",
-              `Method "${implMethod.name}" in implementation "${impl.id}": the function "${fnSymbol}" in "${file}" calls ${crossings.size} modelled method(s) of OTHER components living in that same file, and no narrative step declares the call \u2014 ${detail}. Sharing a file does not make the hop internal: it crosses a component boundary nothing imports, so no file-level check can see it. Narrate the call, or move the code so the boundary is real.`,
+              `Method "${implMethod.name}" in implementation "${impl.id}": the function "${fnSymbol}" in "${file}" calls ${crossings.size} modelled method(s) of OTHER components living in that same file, and neither a narrative step nor a declared call names it \u2014 ${detail}. Sharing a file does not make the hop internal: it crosses a component boundary nothing imports, so no file-level check can see it. Narrate the call, declare it in \`calls\`, or move the code so the boundary is real.`,
               impl.id,
               entry.draftContext,
               void 0,