@wairon/cli 5.1.1-dev.35 → 5.1.1-dev.36

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.35";
+    WAIRON_VERSION = "5.1.1-dev.36";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -2243,13 +2243,34 @@ var init_step_graph = __esm({
 });
 
 // src/models/step-config.ts
+function stepFieldsFor(type) {
+  const own = STEP_TYPE_FIELDS[type] ?? [];
+  const allowed = /* @__PURE__ */ new Set([...STEP_COMMON_FIELDS, ...own]);
+  for (const field of own) {
+    const twin = STEP_LABEL_TWINS[field];
+    if (twin) allowed.add(twin);
+  }
+  return allowed;
+}
+function isSet(step, field) {
+  const v = step[field];
+  if (v === void 0 || v === null) return false;
+  if (Array.isArray(v) && v.length === 0) return false;
+  return true;
+}
 function flowConfigOn(step) {
-  return FLOW_FIELDS.filter((f) => {
-    const v = step[f];
-    if (v === void 0) return false;
-    if (Array.isArray(v) && v.length === 0) return false;
-    return true;
-  });
+  return FLOW_FIELDS.filter((f) => isSet(step, f));
+}
+function narrativeStepForeignFields(step) {
+  const type = step.type;
+  if (!Object.prototype.hasOwnProperty.call(STEP_TYPE_FIELDS, type)) return [];
+  const allowed = stepFieldsFor(type);
+  return Object.keys(step).filter((f) => !allowed.has(f) && isSet(step, f));
+}
+function listFields(fields) {
+  const quoted = fields.map((f) => `"${f}"`);
+  if (quoted.length === 1) return quoted[0];
+  return `${quoted.slice(0, -1).join(", ")} and ${quoted[quoted.length - 1]}`;
 }
 function stepConfigVerdict(method2) {
   const steps = method2.narrative ?? [];
@@ -2286,8 +2307,10 @@ function stepConfigVerdict(method2) {
     return i !== void 0 && i + 1 < nums.length ? nums[i + 1] : void 0;
   };
   for (const s of steps) {
+    const alreadyNamed = /* @__PURE__ */ new Set();
     if (s.detach && s.type !== "call" && s.type !== "dispatch") {
       malformed(s.stepNumber, `step ${s.stepNumber} (${s.type}) carries "detach" \u2014 fire-and-forget applies to call/dispatch steps only.`);
+      alreadyNamed.add("detach");
     }
     switch (s.type) {
       case "local":
@@ -2295,7 +2318,10 @@ function stepConfigVerdict(method2) {
       case "register":
       case "dispatch": {
         const extra = flowConfigOn(s);
-        if (extra.length) malformed(s.stepNumber, `step ${s.stepNumber} (${s.type}) carries flow config (${extra.join(", ")}) \u2014 use a flow step type instead.`);
+        if (extra.length) {
+          malformed(s.stepNumber, `step ${s.stepNumber} (${s.type}) carries flow config (${extra.join(", ")}) \u2014 use a flow step type instead.`);
+          for (const f of extra) alreadyNamed.add(f);
+        }
         break;
       }
       case "branch":
@@ -2338,6 +2364,14 @@ function stepConfigVerdict(method2) {
         if (s.toStep === void 0) malformed(s.stepNumber, `jump step ${s.stepNumber} requires "toStep".`);
         break;
     }
+    const foreign = narrativeStepForeignFields(s).filter((f) => !alreadyNamed.has(f));
+    if (foreign.length) {
+      problems.push({
+        stepNumber: s.stepNumber,
+        code: "FOREIGN_STEP_FIELD",
+        detail: `step ${s.stepNumber} (${s.type}) carries ${listFields(foreign)}, which a ${s.type} step cannot \u2014 left over from an edit that changed the step's type, configuring nothing. \`wairon doctor --fix\` drops them; give the step the type that carries them instead if that is what it does.`
+      });
+    }
     for (const [field, target] of jumpFieldsOf(s)) {
       if (byNum.has(target)) continue;
       sound = false;
@@ -2363,24 +2397,43 @@ function jumpFieldsOf(s) {
   (s.branches ?? []).forEach((b, i) => fields.push([`branches[${i}].step`, b.step]));
   return fields;
 }
-var FLOW_FIELDS;
+var STEP_TYPE_FIELDS, STEP_COMMON_FIELDS, STEP_LABEL_TWINS, FLOW_STEP_TYPES, FLOW_FIELDS;
 var init_step_config = __esm({
   "src/models/step-config.ts"() {
     "use strict";
+    STEP_TYPE_FIELDS = {
+      local: [],
+      call: ["targetComponent", "targetMethod", "auth", "detach"],
+      register: ["targetComponent", "targetMethod"],
+      dispatch: ["targetComponent", "capability", "auth", "detach"],
+      branch: ["condition", "onTrueStep", "onFalseStep"],
+      switch: ["on", "cases", "defaultStep"],
+      loop: ["loopKind", "over", "condition", "endStep"],
+      try: ["endStep", "catches", "finallyStep"],
+      parallel: ["endStep", "branches"],
+      jump: ["toStep"],
+      return: ["outcome"],
+      throw: ["error"]
+    };
+    STEP_COMMON_FIELDS = [
+      "stepNumber",
+      "label",
+      "description",
+      "type",
+      "assertsGuarantees",
+      "assertsInvariants"
+    ];
+    STEP_LABEL_TWINS = {
+      onTrueStep: "onTrueLabel",
+      onFalseStep: "onFalseLabel",
+      defaultStep: "defaultLabel",
+      endStep: "endLabel",
+      finallyStep: "finallyLabel",
+      toStep: "toLabel"
+    };
+    FLOW_STEP_TYPES = ["branch", "switch", "loop", "try", "parallel", "jump"];
     FLOW_FIELDS = [
-      "condition",
-      "onTrueStep",
-      "onFalseStep",
-      "on",
-      "cases",
-      "defaultStep",
-      "loopKind",
-      "over",
-      "endStep",
-      "catches",
-      "finallyStep",
-      "branches",
-      "toStep"
+      ...new Set(FLOW_STEP_TYPES.flatMap((t) => [...STEP_TYPE_FIELDS[t]]))
     ];
   }
 });
@@ -9798,20 +9851,22 @@ var init_narrative_step_config = __esm({
     init_models();
     narrativeStepConfigRule = {
       name: "narrative-step-config",
-      description: 'The step configuration of L5 narratives: every flow step (branch, switch, loop, try, parallel, jump) carries the config its type requires and no simple step carries flow config, "detach" (fire-and-forget) is legal on call/dispatch steps only, a parallel body is covered by contiguous, ordered arms (>= 2), no two steps share a step number or a label, and every jump field targets an existing step number in the same narrative.',
+      description: 'The step configuration of L5 narratives: every flow step (branch, switch, loop, try, parallel, jump) carries the config its type requires and no simple step carries flow config, "detach" (fire-and-forget) is legal on call/dispatch steps only, no step carries a field foreign to its type, a parallel body is covered by contiguous, ordered arms (>= 2), no two steps share a step number or a label, and every jump field targets an existing step number in the same narrative.',
       codes: [
         { code: "MALFORMED_FLOW_STEP", defaultSeverity: "error", summary: "Flow step missing required config (or flow config on a local/call step)" },
         { code: "INVALID_STEP_JUMP", defaultSeverity: "error", summary: "Jump field targets a step number that does not exist in the narrative" },
-        { code: "DUPLICATE_STEP_LABEL", defaultSeverity: "error", summary: "Two steps in one narrative share a label \u2014 the symbolic anchor later deltas address by" }
+        { code: "DUPLICATE_STEP_LABEL", defaultSeverity: "error", summary: "Two steps in one narrative share a label \u2014 the symbolic anchor later deltas address by" },
+        { code: "FOREIGN_STEP_FIELD", defaultSeverity: "warning", summary: "Step carries a field its own type cannot have \u2014 a leftover of an edit, meaning nothing" }
       ],
       check(ctx) {
+        const severityOf = new Map(narrativeStepConfigRule.codes.map((c) => [c.code, c.defaultSeverity]));
         for (const impl of ctx.implementations) {
           const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const implMethod of impl.methods) {
             if (!implMethod.narrative.length) continue;
             const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
             for (const problem of stepConfigVerdict(implMethod).problems) {
-              ctx.addIssue("error", problem.code, where + problem.detail, impl.id, isDraftCtx);
+              ctx.addIssue(severityOf.get(problem.code) ?? "error", problem.code, where + problem.detail, impl.id, isDraftCtx);
             }
           }
         }
@@ -12402,15 +12457,16 @@ var init_unused_types = __esm({
     init_models();
     unusedTypesRule = {
       name: "unused-types",
-      description: "Flags types no field of any type and no interface method signature references. References are matched through the type-reference grammar (generic arguments, collections, qualified ids), and the declaring type's own generic parameters are left out \u2014 a type parameter is not a reference to a type.",
+      description: "Flags types no field of any type, no interface method signature and no other type's method signature references. References are matched through the type-reference grammar (generic arguments, collections, qualified ids), and the declaring type's own generic parameters are left out \u2014 a type parameter is not a reference to a type. A type named only by its OWN methods stays unused, the way a function that only calls itself is.",
       codes: [
-        { code: "UNUSED_TYPE", defaultSeverity: "warning", summary: "Type never referenced by fields or signatures" }
+        { code: "UNUSED_TYPE", defaultSeverity: "warning", summary: "Type never referenced by fields, signatures or type methods" }
       ],
       check(ctx) {
         const referencedTypes = /* @__PURE__ */ new Set();
-        const markTypeReferenced = (ref) => {
+        const markTypeReferenced = (ref, exceptId) => {
           if (ctx.isBuiltinType(ref)) return;
           for (const spec of ctx.types) {
+            if (spec.id === exceptId) continue;
             if (typeMatchesRef(spec, ref)) {
               referencedTypes.add(spec.id);
             }
@@ -12432,6 +12488,14 @@ var init_unused_types = __esm({
             }
           }
         }
+        for (const t of ctx.types) {
+          for (const m of t.methods) {
+            const refs = methodTypeRefs(m);
+            for (const ref of refs) {
+              markTypeReferenced(ref, t.id);
+            }
+          }
+        }
         for (const t of ctx.types) {
           if (!ctx.isSpecInScope(t.id)) continue;
           if (!referencedTypes.has(t.id)) {
@@ -12440,7 +12504,7 @@ var init_unused_types = __esm({
             ctx.addIssue(
               "warning",
               "UNUSED_TYPE",
-              `Type "${t.id}" is defined but never referenced by any type fields or interface methods.`,
+              `Type "${t.id}" is defined but never referenced by any type field, interface method or other type's method.`,
               t.id,
               isDraftCtx
             );
@@ -21868,6 +21932,44 @@ var init_stereotype_migration = __esm({
   }
 });
 
+// src/core/narrative-repair.ts
+function repairForeignStepFields(apply) {
+  const implementations = loadImplementationSpecs();
+  const repairs = [];
+  const changed = [];
+  for (const impl of implementations) {
+    let touched = false;
+    for (const method2 of impl.methods) {
+      for (const step of method2.narrative) {
+        const fields = narrativeStepForeignFields(step);
+        if (!fields.length) continue;
+        repairs.push({
+          implementation: impl.id,
+          method: method2.name,
+          stepNumber: step.stepNumber,
+          stepType: step.type,
+          fields
+        });
+        for (const field of fields) delete step[field];
+        touched = true;
+      }
+    }
+    if (touched) changed.push(impl);
+  }
+  if (apply && changed.length) {
+    for (const impl of changed) saveImplementationSpec(impl);
+    invalidateSpecCache();
+  }
+  return repairs;
+}
+var init_narrative_repair = __esm({
+  "src/core/narrative-repair.ts"() {
+    "use strict";
+    init_specs2();
+    init_models();
+  }
+});
+
 // src/core/approval.ts
 function diffSize(d) {
   return d.added.length + d.changed.length + d.removed.length;
@@ -22045,6 +22147,7 @@ var init_core = __esm({
     init_treetransfer();
     init_provision();
     init_stereotype_migration();
+    init_narrative_repair();
     init_approval();
     init_approver();
     init_specs2();
@@ -23577,15 +23680,6 @@ function identityKeyOf(field, item) {
       return str(o.name) ?? str(o.id);
   }
 }
-function stepFieldsFor(type) {
-  const own = STEP_TYPE_FIELDS[type] ?? [];
-  const allowed = /* @__PURE__ */ new Set([...STEP_COMMON_FIELDS, ...own]);
-  for (const field of own) {
-    const twin = STEP_LABEL_TWINS[field];
-    if (twin) allowed.add(twin);
-  }
-  return allowed;
-}
 function reportIdentityOf(field, item) {
   if (item !== null && typeof item === "object") {
     const step = item.stepNumber;
@@ -23861,7 +23955,7 @@ function findLegacySpecFiles() {
 function updateSpec(kind, id, delta, hooks) {
   return current().updateSpec(kind, id, delta, hooks);
 }
-var fs17, path23, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, STEP_TYPE_FIELDS, STEP_COMMON_FIELDS, STEP_LABEL_TWINS, SpecWorkspace, workspaces;
+var fs17, path23, NO_ROOT_SUBSYSTEMS, SIGNATURE_TTL_MS, SpecWorkspace, workspaces;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
@@ -23879,36 +23973,6 @@ var init_specs2 = __esm({
     init_diagram();
     NO_ROOT_SUBSYSTEMS = /* @__PURE__ */ new Set();
     SIGNATURE_TTL_MS = 2e3;
-    STEP_TYPE_FIELDS = {
-      local: [],
-      call: ["targetComponent", "targetMethod", "auth", "detach"],
-      register: ["targetComponent", "targetMethod"],
-      dispatch: ["targetComponent", "capability", "auth", "detach"],
-      branch: ["condition", "onTrueStep", "onFalseStep"],
-      switch: ["on", "cases", "defaultStep"],
-      loop: ["loopKind", "over", "condition", "endStep"],
-      try: ["endStep", "catches", "finallyStep"],
-      parallel: ["endStep", "branches"],
-      jump: ["toStep"],
-      return: ["outcome"],
-      throw: ["error"]
-    };
-    STEP_COMMON_FIELDS = [
-      "stepNumber",
-      "label",
-      "description",
-      "type",
-      "assertsGuarantees",
-      "assertsInvariants"
-    ];
-    STEP_LABEL_TWINS = {
-      onTrueStep: "onTrueLabel",
-      onFalseStep: "onFalseLabel",
-      defaultStep: "defaultLabel",
-      endStep: "endLabel",
-      finallyStep: "finallyLabel",
-      toStep: "toLabel"
-    };
     SpecWorkspace = class {
       constructor(rootDir) {
         this.cachedIndex = null;
@@ -28759,6 +28823,9 @@ function listDirectChainedSubprojects2(projectRoot2) {
 function retireSpecialists2(apply) {
   return retireSpecialists(apply);
 }
+function repairForeignStepFields2(apply) {
+  return repairForeignStepFields(apply);
+}
 function defaultPackSelections2() {
   return defaultPackSelections();
 }
@@ -30900,6 +30967,23 @@ async function runDoctor(options = {}) {
     } catch (e) {
       line(tally, "warn", `Could not plan Specialist retirement: ${e instanceof Error ? e.message : String(e)}`);
     }
+    try {
+      const foreign = repairForeignStepFields2(false);
+      if (foreign.length > 0) {
+        console.log(import_chalk12.default.bold("Narrative steps"));
+        for (const repair of foreign) {
+          line(
+            tally,
+            "warn",
+            `${repair.implementation}.${repair.method} step ${repair.stepNumber} (${repair.stepType}) carries ${repair.fields.join(", ")} \u2014 a ${repair.stepType} step cannot.`
+          );
+        }
+        line(tally, "warn", "Run `wairon doctor --fix` to drop them (or give each step the type that carries them).");
+        logger.blank();
+      }
+    } catch (e) {
+      line(tally, "warn", `Could not plan the narrative-step repair: ${e instanceof Error ? e.message : String(e)}`);
+    }
   }
   console.log(import_chalk12.default.bold(`Generated files ${import_chalk12.default.gray("(stale = older than installed)")}`));
   for (const [label, p] of [
@@ -31092,6 +31176,17 @@ async function applyFixes() {
   } catch (e) {
     console.log(`  ${icon("error")} Specialist retirement failed: ${e instanceof Error ? e.message : String(e)}`);
   }
+  try {
+    const repairs = repairForeignStepFields2(true);
+    if (repairs.length > 0) {
+      console.log(`  ${icon("ok")} Dropped foreign fields from ${repairs.length} narrative step(s):`);
+      for (const repair of repairs) {
+        console.log(`      ${repair.implementation}.${repair.method} step ${repair.stepNumber} (${repair.stepType}): ${repair.fields.join(", ")}`);
+      }
+    }
+  } catch (e) {
+    console.log(`  ${icon("error")} Narrative-step repair failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
   const { runMcpInstall: runMcpInstall2 } = (init_mcp(), __toCommonJS(mcp_exports));
   if (targets.includes("claude")) {
     try {