@cosmicdrift/kumiko-framework 0.289.0 → 0.290.0

package/src/engine/__tests__/entity-presave-wiring.integration.test.ts

@@ -20,8 +20,12 @@ const contactEntity = createEntity({
     // hook) writes it. secretNote's ownership rule checks authorId, so
     // create only succeeds if the hook ran BEFORE the field-ownership check
     // (kumiko-framework#1672 — see also event-store-executor-write.ts).
-    authorId: createTextField(),
-    secretNote: createTextField({ access: { write: { User: from("user:id", "authorId") } } }),
+    authorId: createTextField({ personal: false, reason: "test_fixture" }),
+    secretNote: createTextField({
+      personal: false,
+      reason: "test_fixture",
+      access: { write: { User: from("user:id", "authorId") } },
+    }),
   },
 });
 

package/src/engine/__tests__/factories-long-text.test.ts

@@ -41,7 +41,12 @@ describe("createLongTextField — runtime shape", () => {
   });
 
   test("encrypted + sensitive flags type-allowed", () => {
-    const f = createLongTextField({ encrypted: true, sensitive: true });
+    const f = createLongTextField({
+      personal: false,
+      reason: "test_fixture",
+      encrypted: true,
+      sensitive: true,
+    });
     expect(f.encrypted).toBe(true);
     expect(f.sensitive).toBe(true);
   });

package/src/engine/boot-validator/__tests__/record-owned.test.ts

@@ -7,9 +7,19 @@
 import { describe, expect, test } from "bun:test";
 import { defineFeature } from "../../define-feature";
 import { createEntity, createTextField } from "../../factories";
-import type { FeatureDefinition } from "../../types";
+import type { FeatureDefinition, TextFieldDef } from "../../types";
 import { validateRecordOwnedSubjects } from "../record-owned";
 
+// Presence/absence of the annotation is the test variable here; after #2810
+// the factory can no longer produce the unannotated shape.
+const unannotatedText: TextFieldDef = {
+  type: "text",
+  maxLength: 200,
+  required: false,
+  searchable: false,
+  sortable: false,
+};
+
 function featureWith(
   idType: "serial" | "uuid" | undefined,
   withRecordOwnedField: boolean,
@@ -23,7 +33,7 @@ function featureWith(
         fields: {
           body: withRecordOwnedField
             ? createTextField({ personal: { of: "id" }, find: "none" })
-            : createTextField(),
+            : { ...unannotatedText },
         },
       }),
     );

package/src/engine/boot-validator/action-wiring.ts

@@ -3,6 +3,7 @@ import {
   isFieldsEditSection,
   normalizeEditField,
   normalizeListColumn,
+  sectionFieldSpecs,
 } from "../screen-helpers";
 import type {
   EditFieldSpec,
@@ -125,7 +126,7 @@ function validateEditLayoutNoFunctions(
       continue;
     }
     if (!isFieldsEditSection(section)) continue;
-    for (const fieldSpec of section.fields) {
+    for (const fieldSpec of sectionFieldSpecs(section)) {
       validateEditFieldNoFunctions(featureName, screenId, screenType, fieldSpec);
     }
   }

package/src/engine/boot-validator/screens.ts

@@ -16,6 +16,7 @@ import {
   normalizeEditField,
   normalizeListColumn,
   resolveNavParentScreen,
+  sectionFieldSpecs,
 } from "../screen-helpers";
 import type { EntityDefinition, FeatureDefinition, FieldDefinition } from "../types";
 import { metricField } from "../types";
@@ -608,15 +609,6 @@ function validateFieldsXorGroups(
   }
 }
 
-function flattenFieldsOrGroups(section: {
-  readonly fields: readonly EditFieldSpec[];
-  readonly groups?: readonly { readonly fields: readonly EditFieldSpec[] }[];
-}): readonly EditFieldSpec[] {
-  return section.groups !== undefined
-    ? section.groups.flatMap((group) => group.fields)
-    : section.fields;
-}
-
 function validateFormLayoutSections(
   featureName: string,
   screenId: string,
@@ -657,7 +649,7 @@ function validateFormLayoutSections(
       );
     }
     validateFieldsXorGroups(`[Feature ${featureName}] Screen "${screenId}" (${context})`, section);
-    for (const fieldSpec of flattenFieldsOrGroups(section)) {
+    for (const fieldSpec of sectionFieldSpecs(section)) {
       const normalized = normalizeEditField(fieldSpec);
       if (!fieldNames.has(normalized.field)) {
         throw new Error(
@@ -1420,7 +1412,7 @@ export function validateScreens(
           `[Feature ${feature.name}] Screen "${screenId}" (configEdit)`,
           section,
         );
-        for (const fieldSpec of flattenFieldsOrGroups(section)) {
+        for (const fieldSpec of sectionFieldSpecs(section)) {
           const normalized = normalizeEditField(fieldSpec);
           if (!fieldNames.has(normalized.field)) {
             throw new Error(
@@ -1837,7 +1829,7 @@ export function validateScreens(
           `[Feature ${feature.name}] Screen "${screenId}" (entityEdit)`,
           section,
         );
-        for (const fieldSpec of flattenFieldsOrGroups(section)) {
+        for (const fieldSpec of sectionFieldSpecs(section)) {
           const normalized = normalizeEditField(fieldSpec);
           if (!fieldNames.has(normalized.field)) {
             throw new Error(

package/src/engine/index.ts

@@ -266,6 +266,7 @@ export {
   isWriteFormEditSection,
   normalizeEditField,
   normalizeListColumn,
+  sectionFieldSpecs,
 } from "./screen-helpers";
 export type { TransitionGraph } from "./state-machine";
 export { defineTransitions, guardTransition } from "./state-machine";

package/src/engine/qualified-name.ts

@@ -130,6 +130,15 @@ export function isKebabSegment(name: string): boolean {
   return QN_SEGMENT.test(name);
 }
 
+// Owning scope of a qualified name — the segment before the first ":".
+// Deliberately lenient where parseQn() throws: callers here hold names that
+// may be unqualified (system consumers, ad-hoc jobs) and want undefined, not
+// an exception.
+export function qnScope(qualifiedName: string): string | undefined {
+  const idx = qualifiedName.indexOf(":");
+  return idx > 0 ? qualifiedName.slice(0, idx) : undefined;
+}
+
 // Build a fully-qualified entity name from a feature name + QN type + short
 // name, running both names through toKebab first. This is the canonical
 // "how the registry qualifies things" helper — both createRegistry and

package/src/event-store/__tests__/backfill-pii.integration.test.ts

@@ -42,7 +42,7 @@ const BIDX_KEY = Buffer.alloc(32, 5).toString("base64");
 const contactEntity = createEntity({
   fields: {
     email: createTextField({ required: true, personal: "self", find: "exact" }),
-    displayName: createTextField(),
+    displayName: createTextField({ personal: false, reason: "test_fixture" }),
   },
 });
 const contactTable = buildEntityTable("contact", contactEntity);
@@ -82,7 +82,7 @@ const signalsFeature = defineFeature("signals", (r) => {
 // absent from an old event's payload, unlike contact.email (self-subject via row id).
 const noteEntity = createEntity({
   fields: {
-    authorId: createTextField(),
+    authorId: createTextField({ personal: false, reason: "test_fixture" }),
     body: createTextField({ personal: { of: "authorId" }, find: "none" }),
   },
 });

package/src/event-store/__tests__/event-attribution.integration.test.ts

@@ -0,0 +1,186 @@
+// #3043 — event attribution. append() stamps metadata.feature +
+// metadata.handler from the ambient execution scope, below every envelope
+// builder, so no writer can forget it.
+//
+// Claims pinned here:
+//   1. Dispatch path: an event a write-handler appends carries the handler's
+//      qualified name and its owning feature.
+//   2. In-process path: the entity-executor's CRUD event carries the SAME
+//      attribution although nothing was passed through its signature.
+//   3. MSP-apply: an event an apply writes is attributed to the consumer, not
+//      to the handler that started the chain.
+//   4. No scope: a bare append() stamps the sentinel, never a guess.
+//   5. appendRaw stays unstamped — historical rows keep their metadata verbatim
+//      and stay readable without the new fields.
+
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { UNATTRIBUTED_ORIGIN } from "@cosmicdrift/kumiko-types/event-store-types";
+import { z } from "zod";
+import { createEventStoreExecutor } from "../../db/event-store-executor";
+import { selectMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
+import { createEntity, createTextField, defineFeature } from "../../engine";
+import {
+  resetEventStore,
+  setupTestStack,
+  type TestStack,
+  TestUsers,
+  unsafeCreateEntityTable,
+} from "../../stack";
+import { generateId as uuid } from "../../utils";
+import { appendRaw } from "../admin-api";
+import { append } from "../event-store";
+import { eventsTable } from "../events-schema";
+
+const orderEntity = createEntity({
+  table: "read_attribution_orders",
+  fields: {
+    item: createTextField({ personal: false, reason: "test_fixture", required: true }),
+  },
+});
+
+const orderTable = buildEntityTable("attr-order", orderEntity);
+
+const PLACED = "attribution:event:placed";
+const CONFIRMED = "attribution:event:confirmed";
+const PLACE_HANDLER = "attribution:write:order:place";
+const CONFIRMER_MSP = "attribution:projection:confirmer";
+
+const attributionFeature = defineFeature("attribution", (r) => {
+  r.entity("attr-order", orderEntity);
+
+  const placed = r.defineEvent("placed", z.object({ orderId: z.uuid() }), { piiFields: "none" });
+  const confirmed = r.defineEvent("confirmed", z.object({ orderId: z.uuid() }), {
+    piiFields: "none",
+  });
+
+  const orderExecutor = createEventStoreExecutor(orderTable, orderEntity, {
+    entityName: "attr-order",
+  });
+
+  r.writeHandler(
+    "order:place",
+    z.object({ item: z.string() }),
+    async (event, ctx) => {
+      const created = await orderExecutor.create({ item: event.payload.item }, event.user, ctx.db);
+      if (!created.isSuccess) return created;
+      await ctx.unsafeAppendEvent({
+        aggregateId: String(created.data.id),
+        aggregateType: "attr-order",
+        type: placed.name,
+        payload: { orderId: String(created.data.id) },
+      });
+      return created;
+    },
+    { access: { roles: ["Admin"] } },
+  );
+
+  r.multiStreamProjection({
+    name: "confirmer",
+    apply: {
+      [placed.name]: async (event, _tx, ctx) => {
+        if (!ctx) throw new Error("MSP-apply ctx missing — regression of C.2b wiring");
+        await ctx.unsafeAppendEvent({
+          aggregateId: event.aggregateId,
+          aggregateType: "attr-order",
+          type: confirmed.name,
+          payload: { orderId: event.aggregateId },
+        });
+      },
+    },
+  });
+});
+
+let stack: TestStack;
+const admin = TestUsers.admin;
+
+beforeAll(async () => {
+  stack = await setupTestStack({ features: [attributionFeature], systemHooks: [] });
+  await unsafeCreateEntityTable(stack.db, orderEntity, "attr-order");
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+afterEach(async () => {
+  await resetEventStore(stack, ["read_attribution_orders"]);
+});
+
+type Origin = { feature?: string; handler?: string };
+
+async function originOf(type: string): Promise<Origin> {
+  const rows = await selectMany(stack.db, eventsTable);
+  const row = rows.find((r: Record<string, unknown>) => r["type"] === type);
+  expect(row).toBeDefined();
+  return (row?.["metadata"] ?? {}) as Origin;
+}
+
+describe("#3043 — event attribution from the execution scope", () => {
+  test("dispatch path: ctx.appendEvent stamps the handler and its feature", async () => {
+    await stack.http.writeOk(PLACE_HANDLER, { item: "widget" }, admin);
+
+    expect(await originOf(PLACED)).toMatchObject({
+      feature: "attribution",
+      handler: PLACE_HANDLER,
+    });
+  });
+
+  test("in-process path: the entity-executor CRUD event carries the same attribution", async () => {
+    await stack.http.writeOk(PLACE_HANDLER, { item: "sprocket" }, admin);
+
+    // Nothing is threaded through createEntityExecutor → EventStoreExecutor.write —
+    // the write runs inside the handler's scope, so the stamp finds it anyway.
+    expect(await originOf("attr-order.created")).toMatchObject({
+      feature: "attribution",
+      handler: PLACE_HANDLER,
+    });
+  });
+
+  test("MSP-apply: the follow-up event is attributed to the consumer, not the trigger", async () => {
+    await stack.http.writeOk(PLACE_HANDLER, { item: "gasket" }, admin);
+    await stack.eventDispatcher?.runOnce();
+
+    expect(await originOf(CONFIRMED)).toMatchObject({
+      feature: "attribution",
+      handler: CONFIRMER_MSP,
+    });
+  });
+
+  test("no scope: a bare append() stamps the sentinel instead of guessing", async () => {
+    const aggregateId = uuid();
+    await append(stack.db, {
+      aggregateId,
+      aggregateType: "attr-order",
+      tenantId: admin.tenantId,
+      expectedVersion: 0,
+      type: PLACED,
+      payload: { orderId: aggregateId },
+      metadata: { userId: admin.id },
+    });
+
+    expect(await originOf(PLACED)).toMatchObject({
+      feature: UNATTRIBUTED_ORIGIN,
+      handler: UNATTRIBUTED_ORIGIN,
+    });
+  });
+
+  test("appendRaw keeps historical metadata verbatim and stays readable", async () => {
+    const aggregateId = uuid();
+    await appendRaw(stack.db, {
+      aggregateId,
+      aggregateType: "attr-order",
+      tenantId: admin.tenantId,
+      expectedVersion: 0,
+      type: CONFIRMED,
+      payload: { orderId: aggregateId },
+      metadata: { userId: admin.id },
+      createdAt: Temporal.Instant.from("2023-01-15T10:00:00Z"),
+      createdBy: admin.id,
+    });
+
+    const origin = await originOf(CONFIRMED);
+    expect(origin.feature).toBeUndefined();
+    expect(origin.handler).toBeUndefined();
+  });
+});

package/src/event-store/event-store.ts

@@ -1,4 +1,8 @@
-import type { EventMetadata, StoredEvent } from "@cosmicdrift/kumiko-types/event-store-types";
+import {
+  type EventMetadata,
+  type StoredEvent,
+  UNATTRIBUTED_ORIGIN,
+} from "@cosmicdrift/kumiko-types/event-store-types";
 // Value-only import, aliased to avoid shadowing the ambient global
 // `Temporal` TYPE this file's other Temporal.Instant annotations resolve
 // against (StoredEvent.createdAt et al. — importing the bare name here
@@ -6,6 +10,7 @@ import type { EventMetadata, StoredEvent } from "@cosmicdrift/kumiko-types/event
 // as a runtime value on globalThis, so the un-aliased call below crashed
 // with "Temporal is not defined" outside boot paths that install it (#1480).
 import { Temporal as TemporalPolyfill } from "temporal-polyfill";
+import { requestContext } from "../api/request-context";
 import { encryptEventPayloadPii } from "../crypto/event-pii";
 import type { DbRunner } from "../db";
 import { constraintOf, isUniqueViolation } from "../db/pg-error";
@@ -83,7 +88,7 @@ export async function append(db: DbRunner, event: EventToAppend): Promise<Stored
     aggregateType: event.aggregateType,
     aggregateId: event.aggregateId,
   });
-  const toStore = payload === event.payload ? event : { ...event, payload };
+  const toStore = stampOrigin(payload === event.payload ? event : { ...event, payload });
   const newVersion = toStore.expectedVersion + 1;
   const eventVersion = toStore.eventVersion ?? 1;
 
@@ -116,6 +121,22 @@ export async function append(db: DbRunner, event: EventToAppend): Promise<Stored
   }
 }
 
+// #3043 — attribution is derived from the execution scope, never taken from
+// the caller: a passed-in value can lie about who wrote the row, a derived
+// one cannot. Hence overwrite rather than merge. appendRaw/appendRawBatch
+// bypass this deliberately — they replay historical rows verbatim.
+function stampOrigin(event: EventToAppend): EventToAppend {
+  const origin = requestContext.get();
+  return {
+    ...event,
+    metadata: {
+      ...event.metadata,
+      feature: origin?.feature ?? UNATTRIBUTED_ORIGIN,
+      handler: origin?.handler ?? UNATTRIBUTED_ORIGIN,
+    },
+  };
+}
+
 type InsertReturn = { id: bigint; createdAt: Temporal.Instant };
 
 async function insertFirstEvent(

package/src/jobs/job-runner.ts

@@ -4,6 +4,7 @@ import { requestContext } from "../api/request-context";
 import type { DbConnection, DbRow } from "../db/connection";
 import { createTenantDb, createUncheckedSystemDb, type TenantDb } from "../db/tenant-db";
 import { createDerivativesContext } from "../derivatives/derivatives-context";
+import { qnScope } from "../engine/qualified-name";
 import { createSystemUser } from "../engine/system-user";
 import {
   type AppContext,
@@ -665,8 +666,15 @@ export function createJobRunner(options: JobRunnerOptions): JobRunner {
 
     const runInSpan = async (): Promise<void> => {
       try {
-        await requestContext.run({ requestId: jobRequestId, correlationId: jobCorrelationId }, () =>
-          jobDef.handler(payload, jobContext),
+        await requestContext.run(
+          {
+            requestId: jobRequestId,
+            correlationId: jobCorrelationId,
+            // #3043 — events a job writes carry the job as their origin.
+            handler: jobName,
+            feature: qnScope(jobName),
+          },
+          () => jobDef.handler(payload, jobContext),
         );
         const duration = Date.now() - startTime;
         await options.onJobComplete?.(jobName, jobId, duration, logs);

package/src/pipeline/active-membership.ts

@@ -97,18 +97,21 @@ export function resolvePrincipalPlugin(registry: Registry): PrincipalStatusPlugi
   return usage.options;
 }
 
-function resolveLifecyclePlugin(registry: Registry): TenantLifecycleStatusPlugin | undefined {
+export function resolveTenantLifecyclePlugin(
+  registry: Registry,
+  caller: string,
+): TenantLifecycleStatusPlugin | undefined {
   const usages = registry.getExtensionUsages(EXT_TENANT_LIFECYCLE_STATUS);
   if (usages.length > 1) {
     throw new InternalError({
-      message: `dispatcher.resolveActiveMembership: multiple "${EXT_TENANT_LIFECYCLE_STATUS}" providers registered — exactly one (or zero) is expected.`,
+      message: `${caller}: multiple "${EXT_TENANT_LIFECYCLE_STATUS}" providers registered — exactly one (or zero) is expected.`,
     });
   }
   const usage = usages[0];
   if (!usage) return undefined;
   if (!isTenantLifecycleStatusPlugin(usage.options)) {
     throw new InternalError({
-      message: `dispatcher.resolveActiveMembership: "${usage.entityName}" registered under "${EXT_TENANT_LIFECYCLE_STATUS}" without a resolveStatus(tenantId, {db}) — extension options must be a TenantLifecycleStatusPlugin.`,
+      message: `${caller}: "${usage.entityName}" registered under "${EXT_TENANT_LIFECYCLE_STATUS}" without a resolveStatus(tenantId, {db}) — extension options must be a TenantLifecycleStatusPlugin.`,
     });
   }
   return usage.options;
@@ -160,7 +163,10 @@ export async function resolveActiveMembershipFn(
     return { kind: "rejected", reason: "principal_blocked" };
   }
 
-  const lifecyclePlugin = resolveLifecyclePlugin(registry);
+  const lifecyclePlugin = resolveTenantLifecyclePlugin(
+    registry,
+    "dispatcher.resolveActiveMembership",
+  );
   if (lifecyclePlugin) {
     const lifecycle = await lifecyclePlugin.resolveStatus(tenantId, { db });
     if (isTeardownRejected(lifecycle, policy)) {

package/src/pipeline/append-event-core.ts

@@ -1,6 +1,6 @@
 import { requestContext } from "../api/request-context";
 import type { DbRunner } from "../db/connection";
-import { toKebab } from "../engine/qualified-name";
+import { qnScope, toKebab } from "../engine/qualified-name";
 import type { AppendEventArgs, Registry, TenantId } from "../engine/types";
 import { InternalError, validationErrorFromZod } from "../errors";
 import { isStreamArchived } from "../event-store/archive";
@@ -32,15 +32,6 @@ export type AppendDomainEventCoreDeps = {
   readonly callerFeature?: string;
 };
 
-// Extract the owning feature from a qualified event name. Events are
-// registered as "<feature>:event:<short>" (see registry.ts qualify()) so the
-// prefix before the first ":" is the owner. Falls back to undefined if the
-// name isn't qualified — callers then skip the cross-feature check.
-function eventOwnerFeature(qualifiedName: string): string | undefined {
-  const idx = qualifiedName.indexOf(":");
-  return idx > 0 ? qualifiedName.slice(0, idx) : undefined;
-}
-
 // System-event prefix: events under this namespace bypass the registry +
 // ownership checks. Reserved for framework-internal coordination (step-
 // engine deferred dispatch, lifecycle signals). The matching MSP filters
@@ -71,7 +62,7 @@ export async function appendDomainEventCore(
   // into kebab-case for the event/handler names (pubsub-orders:event:…) — so
   // we compare the kebab form on both sides.
   if (deps.callerFeature && !isSystemEvent) {
-    const owner = eventOwnerFeature(args.type);
+    const owner = qnScope(args.type);
     const callerKebab = toKebab(deps.callerFeature);
     if (owner && owner !== callerKebab) {
       throw new InternalError({

package/src/pipeline/dispatch-shared.ts

@@ -1,4 +1,4 @@
-import { requestContext } from "../api/request-context";
+import { requestContext, runWithOrigin } from "../api/request-context";
 import type { SseBroker } from "../api/sse-broker";
 import type { DbConnection, DbRunner, DbTx } from "../db/connection";
 import { runInSavepoint, selectMany } from "../db/query";
@@ -907,7 +907,12 @@ export async function runHandlerInstrumented<T>(
       },
       async (span) => {
         try {
-          const result = await inner();
+          // #3043 — everything the handler writes, including entity-executor
+          // writes below it, is attributed to this handler.
+          const result = await runWithOrigin(
+            { handler: type, feature: registry.getHandlerFeature(type) },
+            inner,
+          );
           if (operation === "write" && isFailedWriteResult(result)) {
             success = false;
             errorClass = result.error?.code ?? "UnknownError";
@@ -963,11 +968,18 @@ export async function* runStreamInstrumented<T>(
     attributes: dispatcherSpanAttributes(type, "stream", user, registry.getHandlerFeature(type)),
   });
   const it = inner();
+  // Each pull re-enters both scopes: AsyncLocalStorage does not survive a
+  // generator suspension, so wrapping inner() once would leave every event a
+  // stream writes unattributed.
+  const inScope = <R>(fn: () => R): R =>
+    runWithOrigin({ handler: type, feature: registry.getHandlerFeature(type) }, () =>
+      observabilityContext.run({ activeSpan: span }, fn),
+    );
   try {
-    let next = await observabilityContext.run({ activeSpan: span }, () => it.next());
+    let next = await inScope(() => it.next());
     while (!next.done) {
       yield next.value;
-      next = await observabilityContext.run({ activeSpan: span }, () => it.next());
+      next = await inScope(() => it.next());
     }
     completedNormally = true;
     return next.value;
@@ -980,7 +992,7 @@ export async function* runStreamInstrumented<T>(
   } finally {
     // forward close so inner()'s finally still fires — yield* did this for free
     try {
-      await observabilityContext.run({ activeSpan: span }, () => it.return?.(undefined));
+      await inScope(() => it.return?.(undefined));
     } catch (closeError) {
       // Only fold this in when nothing has already failed — a close-time
       // error while an earlier error is in flight would mask the real

package/src/pipeline/event-dispatcher-delivery.ts

@@ -14,6 +14,7 @@ import {
 } from "../db/queries/event-consumer";
 import { selectEventsHeadId } from "../db/queries/event-store";
 import { coerceRow, extractTableInfo, selectMany } from "../db/query";
+import { qnScope } from "../engine/qualified-name";
 import type { AppContext } from "../engine/types";
 import { eventsTable, toStoredEvent as rowToStoredEvent } from "../event-store";
 import {
@@ -240,9 +241,20 @@ export async function deliverEvents(
       const correlationId = stored.metadata.correlationId ?? requestContext.generateId();
       const causationId = String(stored.id);
       const requestId = requestContext.generateId();
-      await requestContext.run({ requestId, correlationId, causationId }, async () => {
-        await consumer.handler(stored, context);
-      });
+      // #3043 — an event this apply writes is attributed to the consumer, not
+      // to whatever wrote the triggering event; causationId already links back.
+      await requestContext.run(
+        {
+          requestId,
+          correlationId,
+          causationId,
+          handler: consumer.name,
+          feature: consumer.featureName ?? qnScope(consumer.name),
+        },
+        async () => {
+          await consumer.handler(stored, context);
+        },
+      );
       cursor = row.id;
       attempts = 0;
       lastError = null;

package/src/stack/__tests__/ownership-boot-guard.integration.test.ts

@@ -37,7 +37,7 @@ function memoEntity(access: Parameters<typeof createEntity>[0]["access"]) {
   return createEntity({
     table: "fwbootguard_memos",
     fields: {
-      ownerId: createTextField({ required: true }),
+      ownerId: createTextField({ personal: false, reason: "test_fixture", required: true }),
       title: createTextField({ personal: false, reason: "test_fixture", required: true }),
     },
     ...(access ? { access } : {}),

package/src/testing/__tests__/e2e-generator.test.ts

@@ -97,6 +97,56 @@ describe("generateE2ESpec", () => {
     ]);
   });
 
+  test("groups-only sections liefern Required-Felder, Fill-Ops und Text-Assertion", () => {
+    const feature = defineFeature("tasks", (r) => {
+      r.systemScope();
+      r.entity("task", taskEntity);
+      r.writeHandler(
+        defineEntityCreateHandler("task", taskEntity, {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        }),
+      );
+      r.screen({
+        id: "task-list",
+        type: "entityList",
+        entity: "task",
+        columns: ["title", "status", "done"],
+      });
+      r.screen({
+        id: "task-edit",
+        type: "entityEdit",
+        entity: "task",
+        layout: {
+          sections: [
+            {
+              title: "tasks:section.basics",
+              fields: [],
+              groups: [
+                { title: "tasks:group.core", fields: ["title", "status"] },
+                { title: "tasks:group.state", fields: ["done"] },
+              ],
+            },
+          ],
+        },
+      });
+    });
+    const specs = generateE2ESpec(createRegistry([feature]));
+    const editSpecs = specs.filter((s) => s.screenQn === "tasks:screen:task-edit");
+
+    const validates = editSpecs.find((s) => s.kind === "edit-validates-required");
+    if (validates?.kind !== "edit-validates-required") throw new Error("unreachable");
+    expect(validates.requiredFields).toEqual(["title"]);
+
+    const persists = editSpecs.find((s) => s.kind === "edit-save-persists");
+    if (persists?.kind !== "edit-save-persists") throw new Error("unreachable");
+    expect(persists.fills).toEqual([
+      { kind: "fill", field: "title", value: "e2e title" },
+      { kind: "select", field: "status", value: "todo" },
+      { kind: "check", field: "done", value: true },
+    ]);
+    expect(persists.identifyingField).toBe("title");
+  });
+
   test("date emittiert fill, timestamp wird übersprungen (zwei Inputs seit #369)", () => {
     const entity = createEntity({
       table: "events",