fix(metadata): strict boolean-attr parse (JVM) + cross-port @provided error fixture

Closes the two follow-ups flagged after the FR-019 graduation:

1. Boolean-attr validation divergence. The JVM loader silently coerced a
   non-boolean boolean-attr value (Boolean.parseBoolean maps any non-"true" string
   to false) where TS / C# / Python already reject it with ERR_BAD_ATTR_VALUE.
   BooleanAttribute.setValueAsString now parses strictly — accepts only
   case-insensitive true/false and throws otherwise, mirroring IntAttribute's
   parse-throws-on-bad-value contract — so the parser's strict-mode catch surfaces
   ERR_BAD_ATTR_VALUE. Corrects every Java boolean attr, not just @provided.
   - New cross-port loader fixture fixtures/conformance/error-provided-not-boolean
     (@provided: "yes" -> ERR_BAD_ATTR_VALUE), now green in all five ports.
   - No regression: full metadata (987), codegen-spring (140), codegen-kotlin, and
     the metamodel conformance corpus (TS 326, Java 326, C# 596, Python) all pass.

2. Pre-existing TS typecheck errors in metadata/test/template-response-ref.test.ts
   (a `.ts` import extension + an Error-typed `.some()` predicate). Fixed to the
   repo's conventional `.js` import + `(e as { code?: string }).code` cast. (Other
   pre-existing metadata test-file typecheck errors are unrelated to FR-019 and
   left untouched.)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

docs/superpowers/specs/2026-06-06-fr-019-shared-and-provided-enums-design.md

@@ -127,13 +127,20 @@ The corpus is the oracle: TS reference green first, then each port matches.
   the shared `fixtures/codegen-conformance/shared-provided-enum` oracle and its own
   idiomatic per-port conformance test. The positive metamodel fixture
   `fixtures/conformance/enum-provided-shared` pins `@provided` load + canonical
-  round-trip cross-port. `@csEnumType` was never introduced (retired in design).
-- **Deferred:** a *cross-port* loader error fixture for `@provided: "yes"` is not
-  added — TS rejects a non-boolean boolean-attr value at load (`ERR_BAD_ATTR_VALUE`)
-  but the JVM ports silently coerce it (`Boolean.parseBoolean`), a pre-existing
-  plain-boolean-attr-validation divergence orthogonal to FR-019 (no corpus fixture
-  tests a bad boolean value). TS's `field-enum.test.ts` covers the rejection where
-  supported. `@provided` on `object.value` remains the noted follow-up.
+  round-trip cross-port, and the loader error fixture
+  `fixtures/conformance/error-provided-not-boolean` pins `@provided: "yes"` →
+  `ERR_BAD_ATTR_VALUE` in all five ports. `@csEnumType` was never introduced
+  (retired in design).
+- **Boolean-validation alignment:** adding the error fixture surfaced that the JVM
+  loader silently coerced a non-boolean boolean-attr value (`Boolean.parseBoolean`
+  maps any non-`"true"` string to `false`) where TS / C# / Python already reject it.
+  `BooleanAttribute.setValueAsString` now parses strictly (accepts only
+  case-insensitive `true`/`false`, throws otherwise — mirroring `IntAttribute`), so
+  the parser's strict-mode catch surfaces `ERR_BAD_ATTR_VALUE`. This corrects every
+  Java boolean attr, not just `@provided`; the full metadata + conformance + codegen
+  suites pass with no regression.
+- **Follow-up (not here):** `@provided` on `object.value` (reference a hand-written
+  value class) — same attribute, separate slice.
 
 ## Cross-references
 - [ADR-0026](../../../spec/decisions/ADR-0026-shared-and-provided-named-types.md) — `@provided` as a cross-type provenance flag (enums + value objects); shared vs provided orthogonal; Option 2 upgrade path.

fixtures/conformance/error-provided-not-boolean/expected-errors.json

@@ -0,0 +1,15 @@
+{
+  "errors": [
+    {
+      "code": "ERR_BAD_ATTR_VALUE",
+      "source": {
+        "format": "json",
+        "files": [
+          "meta.enums.json"
+        ],
+        "jsonPath": "$['metadata.root'].children[0]['field.enum']"
+      }
+    }
+  ],
+  "warnings": []
+}

fixtures/conformance/error-provided-not-boolean/input/meta.enums.json

@@ -0,0 +1,8 @@
+{
+  "metadata.root": {
+    "package": "acme",
+    "children": [
+      { "field.enum": { "name": "Priority", "abstract": true, "@provided": "yes", "@values": ["LOW", "HIGH"] } }
+    ]
+  }
+}

server/java/metadata/src/main/java/com/metaobjects/attr/BooleanAttribute.java

@@ -91,25 +91,40 @@ public void setValueAsString(String value) {
                 for (String item : items) {
                     String trimmed = item.trim();
                     if (!trimmed.isEmpty()) {
-                        list.add(Boolean.parseBoolean(trimmed));
+                        list.add(parseBooleanStrict(trimmed));
                     }
                 }
                 setValueAsObject(list);
             } else {
                 // Single value
-                Boolean boolValue = Boolean.parseBoolean(value.trim());
+                Boolean boolValue = parseBooleanStrict(value.trim());
                 setValueAsObject(Arrays.asList(boolValue));
             }
         } else {
             // Single value mode: Standard boolean handling
             if (value == null) {
                 setValueAsObject(null);
             } else {
-                setValueAsObject(Boolean.parseBoolean(value.trim()));
+                setValueAsObject(parseBooleanStrict(value.trim()));
             }
         }
     }
 
+    /**
+     * Strict boolean parse — accepts only case-insensitive {@code "true"}/{@code "false"} and
+     * THROWS on any other token (unlike {@link Boolean#parseBoolean}, which silently maps every
+     * non-{@code "true"} string to {@code false}). This mirrors {@link com.metaobjects.attr.IntAttribute}'s
+     * parse-throws-on-bad-value contract so a non-boolean authored value (e.g. {@code @provided: "yes"})
+     * surfaces as {@code ERR_BAD_ATTR_VALUE} through the parser's strict-mode catch, matching the
+     * cross-port loader contract (TS / C# / Python all reject a non-boolean boolean-attr value).
+     */
+    private static boolean parseBooleanStrict(String token) {
+        if ("true".equalsIgnoreCase(token)) return true;
+        if ("false".equalsIgnoreCase(token)) return false;
+        throw new IllegalArgumentException(
+            "Invalid boolean value: '" + token + "' (expected 'true' or 'false')");
+    }
+
     /**
      * Manually create a Boolean MetaAttribute with a value
      */

server/typescript/packages/metadata/test/template-response-ref.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "bun:test";
-import { MetaDataLoader } from "../src/index.ts";
+import { MetaDataLoader } from "../src/index.js";
 
 function meta(responseRef: string) {
   return JSON.stringify({
@@ -20,7 +20,7 @@ describe("template.prompt @responseRef", () => {
   });
   test("unresolved @responseRef is a loader error", async () => {
     const r = await MetaDataLoader.fromString(meta("NoSuchVO"), "json");
-    expect(r.errors.some((e: { code?: string }) => e.code === "ERR_INVALID_TEMPLATE")).toBe(true);
+    expect(r.errors.some((e) => (e as { code?: string }).code === "ERR_INVALID_TEMPLATE")).toBe(true);
   });
 });
 
@@ -35,7 +35,7 @@ test("unresolved @responseRef on a NESTED prompt is a loader error", async () =>
     ] } },
   ] } });
   const r = await MetaDataLoader.fromString(m, "json");
-  expect(r.errors.some((e: { code?: string }) => e.code === "ERR_INVALID_TEMPLATE")).toBe(true);
+  expect(r.errors.some((e) => (e as { code?: string }).code === "ERR_INVALID_TEMPLATE")).toBe(true);
 });
 
 test("template.prompt is allowed as a child of object.entity", async () => {