@@ -142,7 +142,14 @@ open class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         val ctorBuilder = FunSpec.constructorBuilder()
         for (field in obj.metaFields) {
             val baseType = resolvePropertyType(field, obj, loader)
-            val nullable = tphBase || !KotlinGenUtil.isRequiredField(field)
+            // #195: a field derived by origin.aggregate @agg:any|all|collect is COALESCE-guaranteed
+            // non-null in the synthesized read-model view (any→false, all→true, collect→[]), so its
+            // read type is non-null even when the field is NOT @required — matching the Exposed view
+            // column ([KotlinExposedTableGenerator]) so the read/write types stay consistent (the
+            // PR-#80 nullable-column-vs-non-null-read-type invariant). origin.first / origin.computed
+            // keep the conservative nullable default.
+            val nullable = tphBase ||
+                (!KotlinGenUtil.isRequiredField(field) && !KotlinGenUtil.originGuaranteedNonNull(field))
             val propType = if (nullable) baseType.copy(nullable = true) else baseType
             val propName = field.name
             val param = ParameterSpec.builder(propName, propType)
 
@@ -487,7 +487,12 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
                 // field.map is always a single jsonb column.
                 if (field is ObjectField || field is MapField) continue
                 val isPk = field.name in primaryFieldSet
-                val nullable = !isPk && !KotlinGenUtil.isRequiredField(field)
+                // #195: an origin.aggregate @agg:any|all|collect view column is COALESCE-guaranteed
+                // non-null (any→false, all→true, collect→[]), so it is emitted NON-null even when the
+                // field is not @required — keeping the view column consistent with the projection
+                // data-class read type ([KotlinEntityGenerator]); the PR-#80 read/write invariant.
+                val nullable = !isPk && !KotlinGenUtil.isRequiredField(field) &&
+                    !KotlinGenUtil.originGuaranteedNonNull(field)
                 val baseSpec = if (field is EnumField) {
                     // field.enum → typed Exposed enumerationByName column referencing the
                     // generated enum class. Length matches the historical VARCHAR fallback
 
@@ -4,6 +4,8 @@ import com.metaobjects.MetaData
 import com.metaobjects.field.MetaField
 import com.metaobjects.loader.MetaDataLoader
 import com.metaobjects.`object`.MetaObject
+import com.metaobjects.origin.AggregateOrigin
+import com.metaobjects.origin.MetaOrigin
 import com.metaobjects.source.RdbSource
 
 /**
@@ -89,6 +91,27 @@ public object KotlinGenUtil {
         }
     }
 
+    /**
+     * #195 — true iff [field]'s value is derived by an `origin.aggregate` whose `@agg` is one of
+     * the COALESCE-guaranteed-non-null reducers: `any`/`all` (a boolean quantifier, empty set →
+     * `false`/`true` — never null) or `collect` (an array rollup, empty set → `[]` — never null).
+     * A projection/read-model field so derived is non-null in the synthesized view EVEN WHEN it is
+     * not `@required`, so its generated Kotlin type (data-class property AND Exposed view column)
+     * must be non-null — the analog of the TypeScript `originGuaranteedNonNull` predicate that joins
+     * `isRequired()` in the column mapper's not-null decision. `origin.first` (empty related set →
+     * null) and `origin.computed` (expression-dependent) are deliberately NOT here — they keep the
+     * conservative nullable default.
+     *
+     * ADR-0039/ADR-0029: `origin.*` never inherits, so this reads the field's OWN children
+     * (`field.children`) — matching [KotlinPayloadGenerator]'s origin dispatch.
+     */
+    fun originGuaranteedNonNull(field: MetaField<*>): Boolean {
+        val origin = field.children.filterIsInstance<AggregateOrigin>().firstOrNull() ?: return false
+        return origin.agg == MetaOrigin.AGG_ANY ||
+            origin.agg == MetaOrigin.AGG_ALL ||
+            origin.agg == MetaOrigin.AGG_COLLECT
+    }
+
     /**
      * Convert a camelCase identifier to snake_case for use as a physical SQL column name.
      *
 
@@ -9,10 +9,13 @@ import com.metaobjects.loader.MetaDataLoader
 import com.metaobjects.`object`.MetaObject
 import com.metaobjects.origin.AggregateOrigin
 import com.metaobjects.origin.CollectionOrigin
+import com.metaobjects.origin.ComputedOrigin
+import com.metaobjects.origin.FirstOrigin
 import com.metaobjects.origin.MetaOrigin
 import com.metaobjects.origin.PassthroughOrigin
 import com.metaobjects.relationship.MetaRelationship
 import com.metaobjects.template.MetaTemplate
+import com.squareup.kotlinpoet.BOOLEAN
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.DOUBLE
 import com.squareup.kotlinpoet.FileSpec
@@ -40,9 +43,15 @@ import java.nio.file.Paths
  * <ul>
  *   <li>{@code origin.passthrough} (@from "Entity.field") — type of the referenced source field.</li>
  *   <li>{@code origin.aggregate}  (@agg count) — {@code Long}; (@agg avg) — {@code Double};
- *       (@agg sum/min/max) — type of the referenced `@of` field.</li>
+ *       (@agg sum/min/max) — type of the referenced `@of` field; (@agg any/all) — {@code Boolean}
+ *       (a predicate quantifier, #195); (@agg collect) — {@code List<T>} where T is the `@of`
+ *       element type (an array rollup, #195).</li>
  *   <li>{@code origin.collection} (@via "Parent.rel") — {@code List<TargetPayload>}, and the
  *       nested payload class is recursively emitted alongside (deduped per execute() run).</li>
+ *   <li>{@code origin.computed} (@expr ...) — the field's own declared subType, NULLABLE
+ *       (expression nullability is conservative, #195).</li>
+ *   <li>{@code origin.first} (@of "Entity.field" @orderBy [...]) — the `@of` source column's type,
+ *       NULLABLE (an empty related set → null, #195).</li>
  *   <li>No origin child — fall back to {@link KotlinTypeMapper#payloadTypeName(MetaField)}
  *       (parsed JSON value for a `field.string @dbColumnType=jsonb` open bag; otherwise the
  *       same mapping as {@code kotlinTypeName}).</li>
@@ -159,6 +168,13 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
                 is CollectionOrigin -> resolveCollectionType(
                     origin, loader, nestedPkg, outRoot, emittedNestedFqns, emittedEnumFqns, field
                 )
+                // #195 origin.computed: a row-level value; its type is the field's own declared
+                // subType (validation pins the inferred root type == field subType). Conservative
+                // nullable — an expression's null-ness is expression-dependent.
+                is ComputedOrigin -> KotlinTypeMapper.payloadTypeName(field).copy(nullable = true)
+                // #195 origin.first: the @of source column's type, NULLABLE (an empty related set
+                // after @filter selects no row → null).
+                is FirstOrigin -> resolveFirstType(origin, loader, field)
                 else -> KotlinTypeMapper.payloadTypeName(field)
             }
         }
@@ -260,10 +276,12 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
     }
 
     /**
-     * `origin.aggregate @agg X @of "Entity.field"`: type rule —
+     * `origin.aggregate @agg X [@of "Entity.field"]`: type rule —
      *  - count → Long
      *  - avg → Double
      *  - sum/min/max → type of the `@of` field
+     *  - any/all → Boolean (a predicate quantifier; empty set → false/true, never null — #195)
+     *  - collect → List<T> where T is the `@of` element type (array rollup; empty set → [] — #195)
      */
     private fun resolveAggregateType(
         origin: AggregateOrigin,
@@ -273,6 +291,18 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         return when (origin.agg) {
             MetaOrigin.AGG_COUNT -> LONG
             MetaOrigin.AGG_AVG -> DOUBLE
+            // #195 boolean rollup — a quantifier over the related row-set. Always Boolean,
+            // COALESCE-guaranteed non-null (the payload emits fields non-null by default).
+            MetaOrigin.AGG_ANY, MetaOrigin.AGG_ALL -> BOOLEAN
+            // #195 array rollup — List<element-of-@of>, non-null (empty set → []). The @of names
+            // the collected scalar column; payloadTypeName gives its element type.
+            MetaOrigin.AGG_COLLECT -> {
+                val of = origin.of ?: return KotlinTypeMapper.payloadTypeName(fallbackField)
+                val sourceField = resolveDottedFieldRef(loader, of)
+                    ?: return KotlinTypeMapper.payloadTypeName(fallbackField)
+                ClassName("kotlin.collections", "List")
+                    .parameterizedBy(KotlinTypeMapper.payloadTypeName(sourceField))
+            }
             MetaOrigin.AGG_SUM, MetaOrigin.AGG_MIN, MetaOrigin.AGG_MAX -> {
                 val of = origin.of ?: return KotlinTypeMapper.payloadTypeName(fallbackField)
                 val sourceField = resolveDottedFieldRef(loader, of)
@@ -283,6 +313,23 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         }
     }
 
+    /**
+     * `origin.first @of "Entity.field" @orderBy [...]`: type = the `@of` source column's Kotlin
+     * type, made NULLABLE — an empty related set (after `@filter`) selects no row, so the projected
+     * value can be null (#195). Falls back to the payload field's own (nullable) type when `@of`
+     * can't be resolved (defensive — the loader's ValidationPhase gates `@of` presence/shape).
+     */
+    private fun resolveFirstType(
+        origin: FirstOrigin,
+        loader: MetaDataLoader,
+        fallbackField: MetaField<*>,
+    ): TypeName {
+        val of = origin.of ?: return KotlinTypeMapper.payloadTypeName(fallbackField).copy(nullable = true)
+        val sourceField = resolveDottedFieldRef(loader, of)
+            ?: return KotlinTypeMapper.payloadTypeName(fallbackField).copy(nullable = true)
+        return KotlinTypeMapper.payloadTypeName(sourceField).copy(nullable = true)
+    }
+
     /**
      * `origin.collection @via "Parent.relName"`: walk Parent's relationship `relName`
      * to its `@objectRef` target entity, recursively emit a nested payload class
 
@@ -251,6 +251,86 @@ class KotlinPayloadGeneratorTest {
         }
     }
 
+    @Test fun `issue-195 new origins resolve native payload types (any-all Boolean, collect List, first nullable, computed nullable)`() {
+        // The four #195 projection read-model capabilities, hosted on a payload VO. The payload
+        // generator's origin dispatch must type each derived field from its origin (NOT the raw
+        // declared subType), matching the TS/other-port native-typing contract:
+        //   - origin.aggregate @agg:any|all → Boolean (a predicate quantifier over @filter; non-null)
+        //   - origin.aggregate @agg:collect → List<T> where T = the @of element type (non-null)
+        //   - origin.first                  → the @of source type, NULLABLE (empty set → null)
+        //   - origin.computed               → the field's own declared subType, NULLABLE (conservative)
+        //
+        // Shapes obey the #195 loader validation: any/all carry @filter + @via and FORBID @of;
+        // collect is isArray with a subtype-matching @of; first's field is non-@required; computed's
+        // @expr references the host VO's own field (`bio`). The Kotlin dispatch keys on @agg / the
+        // origin subtype, never on @filter/@orderBy.
+        val fx = """{
+          "metadata.root": { "package": "acme::demo", "children": [
+            { "object.entity": { "name": "Author", "children": [
+                { "field.long":   { "name": "id" } },
+                { "relationship.aggregation": { "name": "posts",
+                    "@objectRef": "Post", "@cardinality": "many" } }
+            ] } },
+            { "object.entity": { "name": "Post", "children": [
+                { "field.long":   { "name": "id" } },
+                { "field.string": { "name": "category" } }
+            ] } },
+            { "object.value": { "name": "AuthorSummary", "children": [
+                { "field.string": { "name": "bio" } },
+                { "field.boolean": { "name": "hasAnyPost", "children": [
+                    { "origin.aggregate": { "@agg": "any", "@via": "Author.posts",
+                        "@filter": { "category": "tech" } } }
+                ] } },
+                { "field.boolean": { "name": "allPosts", "children": [
+                    { "origin.aggregate": { "@agg": "all", "@via": "Author.posts",
+                        "@filter": { "category": "tech" } } }
+                ] } },
+                { "field.string": { "name": "categories", "isArray": true, "children": [
+                    { "origin.aggregate": { "@agg": "collect", "@of": "Post.category", "@via": "Author.posts" } }
+                ] } },
+                { "field.string": { "name": "latestCategory", "children": [
+                    { "origin.first": { "@of": "Post.category", "@via": "Author.posts",
+                        "@orderBy": ["id:desc"] } }
+                ] } },
+                { "field.boolean": { "name": "hasBio", "children": [
+                    { "origin.computed": { "@expr": { "op": "isNotNull", "arg": { "field": "bio" } } } }
+                ] } }
+            ] } },
+            { "template.prompt": { "name": "AuthorStats",
+                "@payloadRef": "AuthorSummary", "@textRef": "demo/author" } }
+          ] }
+        }""".trimIndent()
+
+        val outDir = Files.createTempDirectory("kpay-195-")
+        try {
+            val gen = KotlinPayloadGenerator()
+            gen.setArgs(mapOf("outputDir" to outDir.toString()))
+            gen.execute(loadString("test-195", fx))
+
+            val emitted = outDir.resolve("acme/demo/prompts/AuthorStatsPayload.kt")
+            assertTrue(Files.exists(emitted),
+                "expected $emitted; files=${Files.walk(outDir).toList()}")
+            val src = Files.readString(emitted)
+
+            // any / all → Boolean (non-null)
+            assertTrue("val hasAnyPost: Boolean" in src && "val hasAnyPost: Boolean?" !in src,
+                "origin.aggregate @agg:any must be non-null Boolean; saw:\n$src")
+            assertTrue("val allPosts: Boolean" in src && "val allPosts: Boolean?" !in src,
+                "origin.aggregate @agg:all must be non-null Boolean; saw:\n$src")
+            // collect → List<String> (non-null), element = @of (Post.category) type
+            assertTrue("val categories: List<String>" in src && "val categories: List<String>?" !in src,
+                "origin.aggregate @agg:collect must be non-null List<String>; saw:\n$src")
+            // first → the @of source type (String), NULLABLE
+            assertTrue("val latestCategory: String?" in src,
+                "origin.first must be nullable @of source type (String?); saw:\n$src")
+            // computed → declared subType (Boolean), NULLABLE (conservative)
+            assertTrue("val hasBio: Boolean?" in src,
+                "origin.computed must be nullable declared subType (Boolean?); saw:\n$src")
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+
     @Test fun `nested field-object objectRef given as a cross-package FQN emits bare payload names, no package-qualified identifier`() {
         // Regression companion to the TS promptRender FQN-leak fix (0.15.17): a payload VO whose
         // naked `field.object @objectRef` points at ANOTHER object.value declared in a DIFFERENT