fix(objectql): the having temporal refusal's remedy is where's, naming the placeholder having now resolves

having resolves {placeholder} tokens through where's resolver, so a remedy
that names only literal forms steers a caller holding a preset name away
from the one spelling that works. The having refusal now reads REMEDY, the
table where and the per-aggregation filter read; the parallel HAVING_REMEDY
table and its docblock are deleted. DATE_YEAR_REMEDY is untouched, and the
time kind's words are the same string as before.

The remedy pin is flipped: it asserts code and status (through the shared
refusal helper), the message's first sentence, the placeholder named in the
remedy, and the remedy equal to the where twin's.

Claude-Session: https://claude.ai/code/session_01N8TPEsoJxPsdSdNKGnNGEN
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/objectql/src/engine-aggregate-having-temporal-door.test.ts

@@ -247,9 +247,32 @@ describe('[#20263] having — a comparand its column cannot read is refused befo
     await expectHavingRefusal(() => ({ d: { $gt: Y10000 } }), [{ field: 'opened_at', dateGranularity: 'day', alias: 'd' }]);
   });
 
-  it('the remedy names the literal forms only, no placeholder', async () => {
-    for (const having of [{ last_placed: { $lt: 'x' } }, { first_opened: { $lt: 'x' } }]) {
-      expect(await expectHavingRefusal(() => having)).not.toContain('{30_days_ago}');
+  // [#20334] `having` resolves placeholders through `where`'s resolver, so its
+  // remedy is `where`'s: it names the relative-date placeholder that a caller
+  // holding a preset name (`last_30_days`) needs, on the two kinds that take one.
+  it('the remedy names the placeholder the resolver knows, in the where twin\'s words', async () => {
+    const CASES: ReadonlyArray<readonly [Record<string, unknown>, Record<string, unknown>, string]> = [
+      [{ last_placed: { $lt: 'last_30_days' } }, { placed_on: { $lt: 'last_30_days' } },
+        "`having` on 'last_placed' (max(placed_on), a date column) compares against \"last_30_days\" at "
+        + 'having.last_placed.$lt, which is not a date value this platform can interpret.'],
+      [{ first_opened: { $lt: 'last_30_days' } }, { opened_at: { $lt: 'last_30_days' } },
+        "`having` on 'first_opened' (min(opened_at), a datetime column) compares against \"last_30_days\" at "
+        + 'having.first_opened.$lt, which is not a datetime value this platform can interpret.'],
+    ];
+    const after = (message: string, marker: string): string => {
+      expect(message).toContain(marker);
+      return message.slice(message.indexOf(marker) + marker.length);
+    };
+    for (const [having, where, firstSentence] of CASES) {
+      // INVALID_FILTER / 400 on both paths, empty or populated, no read.
+      const message = await expectHavingRefusal(() => having);
+      expect(message.startsWith(`aggregate('${OBJECT}'): ${firstSentence} `)).toBe(true);
+      const remedy = after(message, 'The `having` was NOT applied. ');
+      expect(remedy).toContain('"{30_days_ago}"');
+      const twin = await whereTwinOf(where);
+      expect(twin.err?.code).toBe('INVALID_FILTER');
+      expect(twin.err?.status).toBe(400);
+      expect(remedy).toBe(after(twin.err!.message, 'The filter was NOT applied. '));
     }
   });
 });

packages/objectql/src/temporal-comparand-door.ts

@@ -390,21 +390,6 @@ export function assertTemporalComparandsInterpretable(
   );
 }
 
-/**
- * [#20263] The remedy on a `having` column: the literal forms only, no
- * relative-date placeholder, written when `having` resolved none. [#20334]
- * `having` resolves placeholders through `where`'s resolver, so
- * `{30_days_ago}` is a correct spelling here too; these words were left as
- * they were, so no refusal's text moved with that change.
- */
-const HAVING_REMEDY: Record<TemporalComparandKind, string> = {
-  datetime:
-    'Write an ISO-8601 instant ("2026-07-15T00:00:00.000Z"), a bare "YYYY-MM-DD" '
-    + '(read as midnight UTC), or epoch milliseconds.',
-  date: 'Write a "YYYY-MM-DD" calendar day.',
-  time: REMEDY.time,
-};
-
 /**
  * [#20263] Which aggregated column a `having` key names, in the words the
  * author wrote it: `max(placed_on)`, `the day bucket of opened_at`, `the
@@ -471,6 +456,6 @@ export function assertHavingTemporalComparandsInterpretable(
     `aggregate('${object}'): ${column} compares against ${preview(hit.value)} at ${hit.path}, `
     + `which is not a ${hit.kind} value this platform can interpret. Compared with each group as `
     + 'written, it would keep no group or every group, a 200 indistinguishable from a real answer. '
-    + `The \`having\` was NOT applied. ${HAVING_REMEDY[hit.kind]}`,
+    + `The \`having\` was NOT applied. ${REMEDY[hit.kind]}`,
   );
 }