fix(jvm): ADR-0039 — resolve template.* attrs (Java + Kotlin), matching TS + C#

claude · claude · commit dd4828526c66 · 2026-06-30T23:39:11.000-04:00
The prior JVM sweep KEPT template.* attr reads own-only ("cross-port contract reads templates own"), but that reflected the pre-sweep state. TS + C# now RESOLVE template attrs — a template is a registered type that can be an `extends` target, so its attrs inherit; resolving (includeParentData=true, the default) is the ADR-0039 default. Flipped to resolving: - MetaTemplate / OutputTemplate / PromptTemplate / ToolcallTemplate getters (@payloadRef/@textRef/@format/@maxChars/@owner/@since/@requiredTags/ @promptStyle/@requiredSlots/@maxTokens/@model/@responseRef/@toolname). - Render-helper + api-model template @kind/@subjectRef/@htmlBodyRef/ @textBodyRef/@textRef reads (SpringRenderHelperGenerator, JavaApiModelBuilder, KotlinRenderHelperGenerator, KotlinApiModelBuilder). - Root-level template-node iteration → resolving getChildren(type, true) (Spring render/output-parser/output-prompt/payload + Kotlin render/output-prompt/output-parser/extractor/payload/api-model). Left own (unchanged): ValidationPhase per-subtype required-attr checks (eager-throw validation pass, analogous to source/origin/relationship validation own-walks); field @objectref reads already resolve. No golden change (no template-extends fixture exists yet). Tests: metadata 1065, codegen-spring 158, codegen-kotlin 266 — all green. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01GF9xLEQZaPus5Y6opk398n
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractorGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractorGenerator.kt
@@ -71,10 +71,8 @@ open class KotlinExtractorGenerator : MultiFileDirectGeneratorBase<MetaObject>()
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches the sibling generators' deterministic emission.
-        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
-        // reference's root.ownChildren()), so own children is correct.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputParserGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputParserGenerator.kt
@@ -81,10 +81,8 @@ open class KotlinOutputParserGenerator : MultiFileDirectGeneratorBase<MetaObject
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches TS/C#/Python deterministic emission.
-        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
-        // reference's root.ownChildren()), so own children is correct.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputPromptGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputPromptGenerator.kt
@@ -74,10 +74,8 @@ open class KotlinOutputPromptGenerator : MultiFileDirectGeneratorBase<MetaObject
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches TS/C#/Python/Java deterministic emission.
-        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
-        // reference's root.ownChildren()), so own children is correct.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinPayloadGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinPayloadGenerator.kt
@@ -63,10 +63,8 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         // typed as its generated enum class (reusing the entity enum scheme); two fields sharing an
         // abstract enum super collapse onto ONE emitted file.
         val emittedEnumFqns = mutableSetOf<String>()
-        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
-        // reference's root.ownChildren()), so own children is correct.
-        for (md in loader.root.children) {
-            if (md !is MetaTemplate) continue
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        for (md in loader.root.getChildren(MetaTemplate::class.java, true)) {
             emit(md, loader, outRoot, emittedNestedFqns, emittedEnumFqns)
         }
     }
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinRenderHelperGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinRenderHelperGenerator.kt
@@ -79,10 +79,8 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
         val provider = FilesystemProvider(Paths.get(templateRoot))
 
         // Stable name order — matches the other ports' deterministic emission.
-        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
-        // reference's root.ownChildren()), so own children is correct.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {
@@ -299,23 +297,23 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
     // Local helpers
     // -------------------------------------------------------------------------
 
-    // ADR-0039: template.* attrs are read OWN-ONLY by cross-port contract (TS
-    // render-helper uses tmpl.ownAttr). A template's declared refs are authored-here,
-    // not inherited into an effective form. KEPT own to match the reference.
+    // ADR-0039: template.* attrs RESOLVE through extends (includeParentData=true, the
+    // default) — a template is a registered type that can be an `extends` target, so its
+    // refs inherit. Matches the TS reference + C#.
 
-    /** Resolve `@kind` (OWN attr — templates read own, ADR-0039), defaulting to `document`. */
+    /** Resolve `@kind` (RESOLVING attr — ADR-0039), defaulting to `document`. */
     private fun kindOf(template: MetaTemplate): String {
-        if (template is OutputTemplate && template.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) {
-            val v = template.getMetaAttr(TemplateConstants.ATTR_KIND, false).valueAsString
+        if (template is OutputTemplate && template.hasMetaAttr(TemplateConstants.ATTR_KIND)) {
+            val v = template.getMetaAttr(TemplateConstants.ATTR_KIND).valueAsString
             if (!v.isNullOrEmpty()) return v
         }
         return TemplateConstants.KIND_DEFAULT
     }
 
-    /** Read an OWN template attr value, or null if absent (templates read own — ADR-0039). */
+    /** Read a template attr value (RESOLVING — ADR-0039), or null if absent. */
     private fun attr(template: MetaTemplate, attr: String): String? =
-        if (template.hasMetaAttr(attr, false))
-            template.getMetaAttr(attr, false).valueAsString
+        if (template.hasMetaAttr(attr))
+            template.getMetaAttr(attr).valueAsString
         else null
 
     /** Resolve a `@payloadRef` to its `object.value` (rejects entities — payloads must be VOs). */
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiModelBuilder.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiModelBuilder.kt
@@ -77,12 +77,9 @@ class KotlinApiModelBuilder {
         }
 
         // Templates: one unit per template.output under the model root.
-        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
-        // reference's root.ownChildren()), so own children is correct.
-        for (child in loader.root.children) {
-            if (child is OutputTemplate) {
-                units.add(buildTemplateUnit(child, loader))
-            }
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        for (child in loader.root.getChildren(OutputTemplate::class.java, true)) {
+            units.add(buildTemplateUnit(child, loader))
         }
 
         return KotlinApiModel(project, units)
@@ -437,10 +434,10 @@ class KotlinApiModelBuilder {
     }
 
     private fun isEmailKind(tmpl: MetaTemplate): Boolean {
-        // ADR-0039: template.* attrs read OWN-ONLY by cross-port contract (a template's
-        // declared refs are authored-here, not inherited into an effective form).
-        if (!tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) return false
-        val v = runCatching { tmpl.getMetaAttr(TemplateConstants.ATTR_KIND, false).valueAsString }.getOrNull()
+        // ADR-0039: template.* attrs RESOLVE through extends (includeParentData=true,
+        // the default) — matching the TS reference + C#.
+        if (!tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND)) return false
+        val v = runCatching { tmpl.getMetaAttr(TemplateConstants.ATTR_KIND).valueAsString }.getOrNull()
         return TemplateConstants.KIND_EMAIL.equals(v, ignoreCase = true)
     }
 }
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiModelBuilder.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiModelBuilder.java
@@ -1,6 +1,5 @@
 package com.metaobjects.generator.apidocs;
 
-import com.metaobjects.MetaData;
 import com.metaobjects.generator.spring.LlmTraceHelperGenerator;
 import com.metaobjects.generator.spring.SpringControllerGenerator;
 import com.metaobjects.generator.spring.SpringDtoGenerator;
@@ -44,8 +43,8 @@
  *       read DTO only (no VALIDATION / DATA_ACCESS / REST / FILTER — those
  *       generators gate on a writable table entity and skip a projection). A value
  *       object ({@code object.value}) yields MODEL only.</li>
- *   <li><b>Templates</b> (iterated via {@code loader.getRoot().getChildren()}
- *       filtered to {@link MetaTemplate}): each template yields PAYLOAD / RENDER /
+ *   <li><b>Templates</b> (iterated via the resolving
+ *       {@code loader.getRoot().getChildren(MetaTemplate.class, true)}): each template yields PAYLOAD / RENDER /
  *       PROMPT / OUTPUT_PARSER symbols gated by the matching {@code appliesTo}.</li>
  * </ul>
  *
@@ -90,10 +89,9 @@ public JavaApiModel build(MetaDataLoader loader, String project) {
         }
 
         // Templates: one unit per template.* node under the model root.
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate tmpl) {
-                units.add(buildTemplateUnit(tmpl, loader));
-            }
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        for (MetaTemplate tmpl : loader.getRoot().getChildren(MetaTemplate.class, true)) {
+            units.add(buildTemplateUnit(tmpl, loader));
         }
 
         return new JavaApiModel(project, units);
@@ -289,13 +287,13 @@ parser, ApiSymbolKind.OUTPUT_PARSER, fqn(promptsPkg, parser),
 
     /**
      * True when the template's {@code @kind} is {@code email}. ADR-0039: template.*
-     * attrs read OWN-ONLY by cross-port contract (a template's declared refs are
-     * authored-here, not inherited); default {@code document}.
+     * attrs RESOLVE through extends (includeParentData=true, the default) — matching
+     * the TS reference + C#; default {@code document}.
      */
     private static boolean isEmailKind(MetaTemplate tmpl) {
         if (tmpl instanceof OutputTemplate
-                && tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) {
-            String v = tmpl.getMetaAttr(TemplateConstants.ATTR_KIND, false).getValueAsString();
+                && tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND)) {
+            String v = tmpl.getMetaAttr(TemplateConstants.ATTR_KIND).getValueAsString();
             return TemplateConstants.KIND_EMAIL.equals(v);
         }
         return false;
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringOutputParserGenerator.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringOutputParserGenerator.java
@@ -116,9 +116,10 @@ public void execute(MetaDataLoader loader) {
         Path outRoot = Paths.get(outDir.getAbsolutePath());
 
         // Stable name order — matches the other ports' deterministic emission.
+        // ADR-0039: root-scan discipline — resolving children accessor.
         List<MetaTemplate> outputs = new ArrayList<>();
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate t && TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
+        for (MetaTemplate t : loader.getRoot().getChildren(MetaTemplate.class, true)) {
+            if (TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
                 outputs.add(t);
             }
         }
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringOutputPromptGenerator.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringOutputPromptGenerator.java
@@ -82,9 +82,10 @@ public void execute(MetaDataLoader loader) {
         Path outRoot = Paths.get(outDir.getAbsolutePath());
 
         // Stable name order — matches the other ports' deterministic emission.
+        // ADR-0039: root-scan discipline — resolving children accessor.
         List<MetaTemplate> outputs = new ArrayList<>();
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate t && TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
+        for (MetaTemplate t : loader.getRoot().getChildren(MetaTemplate.class, true)) {
+            if (TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
                 outputs.add(t);
             }
         }
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringPayloadGenerator.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringPayloadGenerator.java
@@ -119,12 +119,9 @@ public void execute(MetaDataLoader loader) {
         // Stable name order — matches the other ports' deterministic emission.
         // Iterate ALL MetaTemplate subtypes (prompt / output / toolcall);
         // every template with a @payloadRef gets a payload record.
-        List<MetaTemplate> templates = new ArrayList<>();
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate t) {
-                templates.add(t);
-            }
-        }
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        List<MetaTemplate> templates =
+            new ArrayList<>(loader.getRoot().getChildren(MetaTemplate.class, true));
         templates.sort(Comparator.comparing(MetaTemplate::getName));
 
         for (MetaTemplate tmpl : templates) {
diff --git a/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringRenderHelperGenerator.java b/server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringRenderHelperGenerator.java
@@ -107,10 +107,10 @@ public void execute(MetaDataLoader loader) {
         FilesystemProvider provider = new FilesystemProvider(Paths.get(templateRoot));
 
         // Stable name order — matches the other ports' deterministic emission.
+        // ADR-0039: root-scan discipline — resolving children accessor.
         List<MetaTemplate> outputs = new ArrayList<>();
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate t
-                    && TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
+        for (MetaTemplate t : loader.getRoot().getChildren(MetaTemplate.class, true)) {
+            if (TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
                 outputs.add(t);
             }
         }
@@ -369,29 +369,28 @@ protected static String fieldTreeLiteral(List<PayloadField> fields) {
     // Local helpers
     // -------------------------------------------------------------------------
 
-    // ADR-0039: template.* attrs are read OWN-ONLY by cross-port contract (TS
-    // render-helper uses tmpl.ownAttr for @kind/@payloadRef/@subjectRef/@textRef/…).
-    // A template describes an authored render unit; its refs are declared-here, not
-    // inherited into an effective form. KEPT own to match the reference.
+    // ADR-0039: template.* attrs RESOLVE through extends (includeParentData=true, the
+    // default) — a template is a registered type that can be an `extends` target, so its
+    // refs (@kind/@payloadRef/@subjectRef/@textRef/…) inherit. Matches the TS reference + C#.
 
-    /** Resolve {@code @kind} (OWN attr — templates read own, ADR-0039), defaulting to {@code document}. */
+    /** Resolve {@code @kind} (RESOLVING attr — ADR-0039), defaulting to {@code document}. */
     private static String kindOf(MetaTemplate template) {
         if (template instanceof OutputTemplate
-                && template.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) {
-            String v = template.getMetaAttr(TemplateConstants.ATTR_KIND, false).getValueAsString();
+                && template.hasMetaAttr(TemplateConstants.ATTR_KIND)) {
+            String v = template.getMetaAttr(TemplateConstants.ATTR_KIND).getValueAsString();
             if (v != null && !v.isEmpty()) return v;
         }
         return TemplateConstants.KIND_DEFAULT;
     }
 
-    /** OWN-only template attr presence (templates read own — ADR-0039). */
+    /** Resolving template attr presence (ADR-0039). */
     private static boolean attrPresent(MetaTemplate template, String attr) {
-        return template.hasMetaAttr(attr, false);
+        return template.hasMetaAttr(attr);
     }
 
-    /** OWN-only template attr value (templates read own — ADR-0039). */
+    /** Resolving template attr value (ADR-0039). */
     private static String attr(MetaTemplate template, String attr) {
-        return template.getMetaAttr(attr, false).getValueAsString();
+        return template.getMetaAttr(attr).getValueAsString();
     }
 
     /** Resolve {@code @payloadRef} to its {@code object.value} target (rejects entities). */
diff --git a/server/java/metadata/src/main/java/com/metaobjects/template/MetaTemplate.java b/server/java/metadata/src/main/java/com/metaobjects/template/MetaTemplate.java
@@ -61,64 +61,64 @@ public static void registerTypes(MetaDataRegistry registry) {
     // moved. The former registerSharedAttrs(...) helper is therefore removed.
 
     // -----------------------------------------------------------------------
-    // Accessors — own-only attr reads (mirrors MetaOrigin's getFrom/getVia)
+    // Accessors — resolving attr reads (ADR-0039 default)
     //
-    // ADR-0039: template.* attrs are read OWN-ONLY by cross-port contract (TS + C#
-    // read template attrs via ownAttr/OwnAttr). A template describes an authored
-    // render unit; its declared refs (@payloadRef/@textRef/@format/@maxChars/@owner/
-    // @since/@requiredTags) are declared-here, not inherited into an effective form.
-    // Every `, false` read below is this sanctioned own case.
+    // ADR-0039: template.* is a registered type that can be an `extends` target, so
+    // its attrs inherit — the resolving read (includeParentData=true, the default) is
+    // correct, matching the TS reference + C# (which resolve template attrs). A
+    // template's declared refs (@payloadRef/@textRef/@format/@maxChars/@owner/@since/
+    // @requiredTags) resolve through the extends chain into an effective form.
     // -----------------------------------------------------------------------
 
     /** Returns the raw value of {@code @payloadRef}, or {@code null} if absent. */
     public String getPayloadRef() {
-        return hasMetaAttr(ATTR_PAYLOAD_REF, false)
-            ? getMetaAttr(ATTR_PAYLOAD_REF, false).getValueAsString()
+        return hasMetaAttr(ATTR_PAYLOAD_REF)
+            ? getMetaAttr(ATTR_PAYLOAD_REF).getValueAsString()
             : null;
     }
 
     /** Returns the raw value of {@code @textRef}, or {@code null} if absent. */
     public String getTextRef() {
-        return hasMetaAttr(ATTR_TEXT_REF, false)
-            ? getMetaAttr(ATTR_TEXT_REF, false).getValueAsString()
+        return hasMetaAttr(ATTR_TEXT_REF)
+            ? getMetaAttr(ATTR_TEXT_REF).getValueAsString()
             : null;
     }
 
     /**
      * Returns the value of {@code @format} if set, else {@link TemplateConstants#FORMAT_DEFAULT}.
      */
     public String getFormat() {
-        if (!hasMetaAttr(ATTR_FORMAT, false)) return FORMAT_DEFAULT;
-        String v = getMetaAttr(ATTR_FORMAT, false).getValueAsString();
+        if (!hasMetaAttr(ATTR_FORMAT)) return FORMAT_DEFAULT;
+        String v = getMetaAttr(ATTR_FORMAT).getValueAsString();
         return v != null ? v : FORMAT_DEFAULT;
     }
 
     /** Returns the value of {@code @maxChars}, or {@code null} if absent. */
     public Integer getMaxChars() {
-        if (!hasMetaAttr(ATTR_MAX_CHARS, false)) return null;
+        if (!hasMetaAttr(ATTR_MAX_CHARS)) return null;
         // IntAttribute is parameterized on Integer; load-time conversion via
         // DataConverter guarantees getValue() is Integer or null here.
-        return (Integer) getMetaAttr(ATTR_MAX_CHARS, false).getValue();
+        return (Integer) getMetaAttr(ATTR_MAX_CHARS).getValue();
     }
 
     /** Returns the raw value of {@code @owner}, or {@code null} if absent. */
     public String getOwner() {
-        return hasMetaAttr(ATTR_OWNER, false)
-            ? getMetaAttr(ATTR_OWNER, false).getValueAsString()
+        return hasMetaAttr(ATTR_OWNER)
+            ? getMetaAttr(ATTR_OWNER).getValueAsString()
             : null;
     }
 
     /** Returns the raw value of {@code @since}, or {@code null} if absent. */
     public String getSince() {
-        return hasMetaAttr(ATTR_SINCE, false)
-            ? getMetaAttr(ATTR_SINCE, false).getValueAsString()
+        return hasMetaAttr(ATTR_SINCE)
+            ? getMetaAttr(ATTR_SINCE).getValueAsString()
             : null;
     }
 
     /** Returns the {@code @requiredTags} list, or {@code null} if absent. */
     public List<String> getRequiredTags() {
-        if (!hasMetaAttr(ATTR_REQUIRED_TAGS, false)) return null;
-        Object v = getMetaAttr(ATTR_REQUIRED_TAGS, false).getValue();
+        if (!hasMetaAttr(ATTR_REQUIRED_TAGS)) return null;
+        Object v = getMetaAttr(ATTR_REQUIRED_TAGS).getValue();
         if (v instanceof List<?> list) {
             List<String> out = new ArrayList<>(list.size());
             for (Object o : list) out.add(String.valueOf(o));
diff --git a/server/java/metadata/src/main/java/com/metaobjects/template/OutputTemplate.java b/server/java/metadata/src/main/java/com/metaobjects/template/OutputTemplate.java
diff --git a/server/java/metadata/src/main/java/com/metaobjects/template/PromptTemplate.java b/server/java/metadata/src/main/java/com/metaobjects/template/PromptTemplate.java
diff --git a/server/java/metadata/src/main/java/com/metaobjects/template/ToolcallTemplate.java b/server/java/metadata/src/main/java/com/metaobjects/template/ToolcallTemplate.java

Original file line number	Diff line number	Diff line change
`@@ -63,10 +63,8 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {`
`63`	`63`	`// typed as its generated enum class (reusing the entity enum scheme); two fields sharing an`
`64`	`64`	`// abstract enum super collapse onto ONE emitted file.`
`65`	`65`	`val emittedEnumFqns = mutableSetOf<String>()`
`66`		`- // ADR-0039: root-level declaration scan — root is never extended (matches the TS`
`67`		`- // reference's root.ownChildren()), so own children is correct.`
`68`		`- for (md in loader.root.children) {`
`69`		`- if (md !is MetaTemplate) continue`
	`66`	`+ // ADR-0039: root-scan discipline — resolving children accessor.`
	`67`	`+ for (md in loader.root.getChildren(MetaTemplate::class.java, true)) {`
`70`	`68`	`emit(md, loader, outRoot, emittedNestedFqns, emittedEnumFqns)`
`71`	`69`	`}`
`72`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,12 +77,9 @@ class KotlinApiModelBuilder {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`// Templates: one unit per template.output under the model root.`
`80`		`- // ADR-0039: root-level declaration scan — root is never extended (matches the TS`
`81`		`- // reference's root.ownChildren()), so own children is correct.`
`82`		`- for (child in loader.root.children) {`
`83`		`- if (child is OutputTemplate) {`
`84`		`- units.add(buildTemplateUnit(child, loader))`
`85`		`- }`
	`80`	`+ // ADR-0039: root-scan discipline — resolving children accessor.`
	`81`	`+ for (child in loader.root.getChildren(OutputTemplate::class.java, true)) {`
	`82`	`+ units.add(buildTemplateUnit(child, loader))`
`86`	`83`	`}`
`87`	`84`
`88`	`85`	`return KotlinApiModel(project, units)`
`@@ -437,10 +434,10 @@ class KotlinApiModelBuilder {`
`437`	`434`	`}`
`438`	`435`
`439`	`436`	`private fun isEmailKind(tmpl: MetaTemplate): Boolean {`
`440`		`- // ADR-0039: template.* attrs read OWN-ONLY by cross-port contract (a template's`
`441`		`- // declared refs are authored-here, not inherited into an effective form).`
`442`		`- if (!tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) return false`
`443`		`- val v = runCatching { tmpl.getMetaAttr(TemplateConstants.ATTR_KIND, false).valueAsString }.getOrNull()`
	`437`	`+ // ADR-0039: template.* attrs RESOLVE through extends (includeParentData=true,`
	`438`	`+ // the default) — matching the TS reference + C#.`
	`439`	`+ if (!tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND)) return false`
	`440`	`+ val v = runCatching { tmpl.getMetaAttr(TemplateConstants.ATTR_KIND).valueAsString }.getOrNull()`
`444`	`441`	`return TemplateConstants.KIND_EMAIL.equals(v, ignoreCase = true)`
`445`	`442`	`}`
`446`	`443`	`}`
Original file line number	Diff line number	Diff line change
`@@ -116,9 +116,10 @@ public void execute(MetaDataLoader loader) {`
`116`	`116`	`Path outRoot = Paths.get(outDir.getAbsolutePath());`
`117`	`117`
`118`	`118`	`// Stable name order — matches the other ports' deterministic emission.`
	`119`	`+ // ADR-0039: root-scan discipline — resolving children accessor.`
`119`	`120`	`List<MetaTemplate> outputs = new ArrayList<>();`
`120`		`- for (MetaData child : loader.getRoot().getChildren()) {`
`121`		`- if (child instanceof MetaTemplate t && TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {`
	`121`	`+ for (MetaTemplate t : loader.getRoot().getChildren(MetaTemplate.class, true)) {`
	`122`	`+ if (TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {`
`122`	`123`	`outputs.add(t);`
`123`	`124`	`}`
`124`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,9 +82,10 @@ public void execute(MetaDataLoader loader) {`
`82`	`82`	`Path outRoot = Paths.get(outDir.getAbsolutePath());`
`83`	`83`
`84`	`84`	`// Stable name order — matches the other ports' deterministic emission.`
	`85`	`+ // ADR-0039: root-scan discipline — resolving children accessor.`
`85`	`86`	`List<MetaTemplate> outputs = new ArrayList<>();`
`86`		`- for (MetaData child : loader.getRoot().getChildren()) {`
`87`		`- if (child instanceof MetaTemplate t && TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {`
	`87`	`+ for (MetaTemplate t : loader.getRoot().getChildren(MetaTemplate.class, true)) {`
	`88`	`+ if (TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {`
`88`	`89`	`outputs.add(t);`
`89`	`90`	`}`
`90`	`91`	`}`