@@ -2027,7 +2027,8 @@ os verify --dashboard-windows                  # Also prove each dashboard date
    on every preset's first and last day and the day either side (never after
    today), stamped at UTC noon, owned by the caller and holding every column
    the widget's own filter, the dataset's filter and the measure's filter
-   compare, and read back. The widget is then asked through
+   compare (the smallest record first, every synthesized field if the seed
+   door refuses it), and read back. The widget is then asked through
    `POST /analytics/dataset/query` as the signed-in admin with no window and
    under each of the 13 presets, before and after the fixtures. A preset is
    handed as the spec's `{date-macro}` window for it (`{ $gte: '{7_days_ago}' }`
 
@@ -166,7 +166,9 @@ through the seed door on each preset's first and last day and the day either
 side (never after today), each stamped at UTC noon (a `date` field takes the
 day), owned by the caller, with every column the widget's filter, the
 dataset's filter and the measure's filter compare held to a value they select,
-and read back before anything is judged. Every count is a difference (after
+and read back before anything is judged. A row is the smallest record the CRUD
+derivation offers (its required fields); if the seed door refuses that (an app
+rule that requires a field only in some state), every field it synthesizes. Every count is a difference (after
 the fixtures minus before, under the same window), so the app's own rows
 cancel out, and the widget with no window must count every fixture row before
 any window is judged. A count measure is probed (a `count` of a named field
 
@@ -47,6 +47,19 @@ const ticket = {
 
 const source = {
   manifest: { id: 'com.example.dashboard-window', namespace: 'wnd', version: '0.0.1', type: 'app', name: 'Dashboard Window Fixture' },
+  hooks: [
+    {
+      // An app rule requiring a field only in some state: a closed ticket needs its effort.
+      name: 'wnd_closed_needs_effort',
+      object: 'wnd_ticket',
+      events: ['beforeInsert'],
+      handler: async (ctx: { input: Record<string, unknown> }) => {
+        if (ctx.input.is_closed === true && ctx.input.effort == null) {
+          throw Object.assign(new Error('Effort is required on a closed ticket'), { code: 'VALIDATION_FAILED', status: 400 });
+        }
+      },
+    },
+  ],
   objects: [
     { name: 'wnd_agent', label: 'Agent', fields: { name: { type: 'text', label: 'Name', required: true } } },
     ticket,
@@ -197,6 +210,9 @@ describe('runDashboardWindowProofs — the fixture app', () => {
       }
     }
     expect(widgetOf(report, 'open_tickets').fieldType).toBe('datetime');
+    // The closed tickets meet the app's own rule only with every synthesized field.
+    expect(widgetOf(report, 'closed_tickets').measures[0]!.fixture).toBe('every-field');
+    expect(widgetOf(report, 'open_tickets').measures[0]!.fixture).toBe('smallest');
     expect(widgetOf(report, 'due_window').fieldType).toBe('date');
     expect(widgetOf(report, 'all_tickets').fieldType).toBe('datetime');
   });
 
@@ -193,6 +193,8 @@ export interface DashboardWindowMeasureResult {
   excludedKind?: DashboardWindowExclusion;
   /** The fixture days written (UTC calendar days). */
   days?: string[];
+  /** `smallest` — the required fields only; `every-field` — the seed door refused that, so every field the CRUD derivation synthesizes. */
+  fixture?: 'smallest' | 'every-field';
   /** The control leg: the widget with no window must count every fixture row. */
   unwindowed?: { expected: number; answered?: number; answer?: DashboardWindowAnswer };
   presets: DashboardWindowPresetProbe[];
@@ -515,18 +517,19 @@ function uniqueFields(objectDef: any): Set<string> {
 }
 
 /**
- * The smallest record the CRUD derivation can offer (the shape the sibling
- * families use): its values for the fields the object REQUIRES, so every
- * optional field takes the app's own default; each `date` / `datetime` one day
- * after the one declared before it, and each unique-constrained value made
- * distinct by `n`.
+ * A record the CRUD derivation can offer: by default the smallest (the shape
+ * the sibling families use) — its values for the fields the object REQUIRES,
+ * so every optional field takes the app's own default; with `full`, every
+ * field it synthesizes (what a rule that requires a field only in some state
+ * asks for). Each `date` / `datetime` is one day after the one declared before
+ * it, and each unique-constrained value is made distinct by `n`.
  */
-function fixtureBody(body: Record<string, unknown>, objectDef: any, n: number): Record<string, unknown> {
+function fixtureBody(body: Record<string, unknown>, objectDef: any, n: number, full = false): Record<string, unknown> {
   const unique = uniqueFields(objectDef);
   const out: Record<string, unknown> = {};
   let dates = 0;
   for (const [name, def] of Object.entries<any>(objectDef?.fields ?? {})) {
-    if (def?.required !== true || !(name in body)) continue;
+    if ((!full && def?.required !== true) || !(name in body)) continue;
     let value = body[name];
     if ((def?.type === 'date' || def?.type === 'datetime') && typeof value === 'string') value = laterBy(value, dates++);
     if (unique.has(name) && (typeof value === 'string' || typeof value === 'number')) value = vary(value, n);
@@ -860,24 +863,40 @@ export async function runDashboardWindowProofs(
     const days = fixtureDays(presets, day0);
     const stamp = (day: string) => (fieldType === 'date' ? day : `${day}T12:00:00.000Z`);
     const written: Array<{ day: string; id: string }> = [];
+    // The smallest record first; if the seed door refuses it (an app rule that
+    // requires a field in the state the held columns put the row in), every
+    // field the CRUD derivation synthesizes, and that shape for the rest.
+    let full = false;
     for (const day of days) {
-      const row: Record<string, unknown> = {
-        ...fixtureBody(body, objectDefs.get(c.object!), ++counter),
+      const row = (wide: boolean): Record<string, unknown> => ({
+        ...fixtureBody(body, objectDefs.get(c.object!), ++counter, wide),
         ...(ownerColumn ? { owner_id: principal } : {}),
         ...Object.fromEntries(held),
         [c.field!]: stamp(day),
+      });
+      const seedOne = async (wide: boolean): Promise<string> => {
+        const [made] = await stack.seed(c.object!, [row(wide)]);
+        if (made?.id == null) throw new Error(`the seed of ${c.object} returned no id`);
+        return String(made.id);
       };
       try {
-        const [made] = await stack.seed(c.object!, [row]);
-        if (made?.id == null) throw new Error(`the seed of ${c.object} returned no id`);
-        written.push({ day, id: String(made.id) });
+        let id: string;
+        try {
+          id = await seedOne(full);
+        } catch (first) {
+          if (full || written.length > 0) throw first;
+          full = true;
+          id = await seedOne(true);
+        }
+        written.push({ day, id });
       } catch (e) {
         r.days = days;
         notRun(`the fixture row for ${day} was refused by the seed door: ${clip((e as Error)?.message, 160)}`);
         return;
       }
     }
     r.days = days;
+    r.fixture = full ? 'every-field' : 'smallest';
     // Read back: the stamp and every held column must read as written.
     for (const { day, id } of written) {
       const [got] = await stack.rows(c.object!, { id });