@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/date-context.test.ts

@@ -1,6 +1,9 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { buildTemporalContext, extractUserTimeZoneFromDynamicProfile } from '../daemon/date-context.js';
+import {
+  buildTemporalContext,
+  extractUserTimeZoneFromDynamicProfile,
+} from "../daemon/date-context.js";
 
 // Fixed timestamps for deterministic assertions (all UTC midday to avoid DST edge cases).
 
@@ -23,197 +26,205 @@ const FRI_FEB_27 = Date.UTC(2026, 1, 27, 12, 0, 0);
 // Basic structure
 // ---------------------------------------------------------------------------
 
-describe('buildTemporalContext', () => {
-  test('returns output wrapped in <temporal_context> tags', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toStartWith('<temporal_context>');
-    expect(result).toEndWith('</temporal_context>');
+describe("buildTemporalContext", () => {
+  test("returns output wrapped in <temporal_context> tags", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
+    expect(result).toStartWith("<temporal_context>");
+    expect(result).toEndWith("</temporal_context>");
   });
 
-  test('includes today date and weekday', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('Today: 2026-02-18 (Wednesday)');
+  test("includes today date and weekday", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
+    expect(result).toContain("Today: 2026-02-18 (Wednesday)");
   });
 
-  test('includes timezone', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'America/New_York' });
-    expect(result).toContain('Timezone: America/New_York');
+  test("includes timezone", () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "America/New_York",
+    });
+    expect(result).toContain("Timezone: America/New_York");
   });
 
-  test('includes current local time as ISO 8601 with offset', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('Current local time: 2026-02-18T12:00:00+00:00');
+  test("includes current local time as ISO 8601 with offset", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
+    expect(result).toContain("Current local time: 2026-02-18T12:00:00+00:00");
   });
 
-  test('includes current UTC time from assistant host clock', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('Current UTC time: 2026-02-18T12:00:00.000Z');
+  test("includes current UTC time from assistant host clock", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
+    expect(result).toContain("Current UTC time: 2026-02-18T12:00:00.000Z");
   });
 
-  test('documents assistant host as the authoritative clock source', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('Clock source: assistant host machine');
+  test("documents assistant host as the authoritative clock source", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
+    expect(result).toContain("Clock source: assistant host machine");
   });
 
-  test('uses user timezone when provided and records source metadata', () => {
+  test("uses user timezone when provided and records source metadata", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
-      hostTimeZone: 'UTC',
-      userTimeZone: 'America/New_York',
+      hostTimeZone: "UTC",
+      userTimeZone: "America/New_York",
     });
-    expect(result).toContain('Timezone: America/New_York');
-    expect(result).toContain('Current local time: 2026-02-18T07:00:00-05:00');
-    expect(result).toContain('Assistant host timezone: UTC');
-    expect(result).toContain('User timezone: America/New_York');
-    expect(result).toContain('Timezone source: user_profile_memory');
+    expect(result).toContain("Timezone: America/New_York");
+    expect(result).toContain("Current local time: 2026-02-18T07:00:00-05:00");
+    expect(result).toContain("Assistant host timezone: UTC");
+    expect(result).toContain("User timezone: America/New_York");
+    expect(result).toContain("Timezone source: user_profile_memory");
   });
 
-  test('uses configured user timezone when profile timezone is unavailable', () => {
+  test("uses configured user timezone when profile timezone is unavailable", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
-      hostTimeZone: 'UTC',
-      configuredUserTimeZone: 'America/Chicago',
+      hostTimeZone: "UTC",
+      configuredUserTimeZone: "America/Chicago",
       userTimeZone: null,
     });
-    expect(result).toContain('Timezone: America/Chicago');
-    expect(result).toContain('Current local time: 2026-02-18T06:00:00-06:00');
-    expect(result).toContain('User timezone: America/Chicago');
-    expect(result).toContain('Timezone source: user_settings');
+    expect(result).toContain("Timezone: America/Chicago");
+    expect(result).toContain("Current local time: 2026-02-18T06:00:00-06:00");
+    expect(result).toContain("User timezone: America/Chicago");
+    expect(result).toContain("Timezone source: user_settings");
   });
 
-  test('configured user timezone takes precedence over profile timezone', () => {
+  test("configured user timezone takes precedence over profile timezone", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
-      hostTimeZone: 'UTC',
-      configuredUserTimeZone: 'America/Los_Angeles',
-      userTimeZone: 'America/New_York',
+      hostTimeZone: "UTC",
+      configuredUserTimeZone: "America/Los_Angeles",
+      userTimeZone: "America/New_York",
     });
-    expect(result).toContain('Timezone: America/Los_Angeles');
-    expect(result).toContain('Current local time: 2026-02-18T04:00:00-08:00');
-    expect(result).toContain('User timezone: America/Los_Angeles');
-    expect(result).toContain('Timezone source: user_settings');
+    expect(result).toContain("Timezone: America/Los_Angeles");
+    expect(result).toContain("Current local time: 2026-02-18T04:00:00-08:00");
+    expect(result).toContain("User timezone: America/Los_Angeles");
+    expect(result).toContain("Timezone source: user_settings");
   });
 
-  test('falls back to host timezone when user timezone is unavailable', () => {
+  test("falls back to host timezone when user timezone is unavailable", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
-      hostTimeZone: 'UTC',
+      hostTimeZone: "UTC",
       userTimeZone: null,
     });
-    expect(result).toContain('Timezone: UTC');
-    expect(result).toContain('User timezone: unknown');
-    expect(result).toContain('Timezone source: assistant_host_fallback');
+    expect(result).toContain("Timezone: UTC");
+    expect(result).toContain("User timezone: unknown");
+    expect(result).toContain("Timezone source: assistant_host_fallback");
   });
 
-  test('accepts UTC/GMT offset-style user timezone values', () => {
+  test("accepts UTC/GMT offset-style user timezone values", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
-      hostTimeZone: 'UTC',
-      userTimeZone: 'UTC+2',
+      hostTimeZone: "UTC",
+      userTimeZone: "UTC+2",
     });
-    expect(result).toContain('Timezone: Etc/GMT-2');
-    expect(result).toContain('Current local time: 2026-02-18T14:00:00+02:00');
-    expect(result).toContain('User timezone: Etc/GMT-2');
-    expect(result).toContain('Timezone source: user_profile_memory');
+    expect(result).toContain("Timezone: Etc/GMT-2");
+    expect(result).toContain("Current local time: 2026-02-18T14:00:00+02:00");
+    expect(result).toContain("User timezone: Etc/GMT-2");
+    expect(result).toContain("Timezone source: user_profile_memory");
   });
 
-  test('accepts fractional UTC/GMT offset-style user timezone values', () => {
+  test("accepts fractional UTC/GMT offset-style user timezone values", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
-      hostTimeZone: 'UTC',
-      userTimeZone: 'UTC+5:30',
+      hostTimeZone: "UTC",
+      userTimeZone: "UTC+5:30",
     });
-    expect(result).toContain('Timezone: +05:30');
-    expect(result).toContain('Current local time: 2026-02-18T17:30:00+05:30');
-    expect(result).toContain('User timezone: +05:30');
-    expect(result).toContain('Timezone source: user_profile_memory');
+    expect(result).toContain("Timezone: +05:30");
+    expect(result).toContain("Current local time: 2026-02-18T17:30:00+05:30");
+    expect(result).toContain("User timezone: +05:30");
+    expect(result).toContain("Timezone source: user_profile_memory");
   });
 
-  test('includes week definitions', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('work week = Monday–Friday');
-    expect(result).toContain('weekend = Saturday–Sunday');
+  test("includes week definitions", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
+    expect(result).toContain("work week = Monday–Friday");
+    expect(result).toContain("weekend = Saturday–Sunday");
   });
 
-  test('formats midnight hours as 00 (never 24) in local ISO output', () => {
+  test("formats midnight hours as 00 (never 24) in local ISO output", () => {
     const justAfterMidnight = Date.UTC(2026, 1, 19, 0, 5, 0);
-    const result = buildTemporalContext({ nowMs: justAfterMidnight, timeZone: 'UTC' });
-    expect(result).toContain('Current local time: 2026-02-19T00:05:00+00:00');
-    expect(result).not.toContain('T24:05:00');
+    const result = buildTemporalContext({
+      nowMs: justAfterMidnight,
+      timeZone: "UTC",
+    });
+    expect(result).toContain("Current local time: 2026-02-19T00:05:00+00:00");
+    expect(result).not.toContain("T24:05:00");
   });
 });
 
-describe('extractUserTimeZoneFromDynamicProfile', () => {
-  test('extracts canonical timezone from explicit timezone profile line', () => {
+describe("extractUserTimeZoneFromDynamicProfile", () => {
+  test("extracts canonical timezone from explicit timezone profile line", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- timezone: Timezone is America/New_York.',
-      '</dynamic-user-profile>',
-    ].join('\n');
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('America/New_York');
+      "<dynamic-user-profile>",
+      "- timezone: Timezone is America/New_York.",
+      "</dynamic-user-profile>",
+    ].join("\n");
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe(
+      "America/New_York",
+    );
   });
 
-  test('extracts timezone token from generic profile text when explicit line is absent', () => {
+  test("extracts timezone token from generic profile text when explicit line is absent", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- location: Travels often between Europe and Asia (currently Europe/Paris).',
-      '</dynamic-user-profile>',
-    ].join('\n');
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Europe/Paris');
+      "<dynamic-user-profile>",
+      "- location: Travels often between Europe and Asia (currently Europe/Paris).",
+      "</dynamic-user-profile>",
+    ].join("\n");
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Europe/Paris");
   });
 
-  test('returns null when no valid timezone is present', () => {
+  test("returns null when no valid timezone is present", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- timezone: Pacific time',
-      '</dynamic-user-profile>',
-    ].join('\n');
+      "<dynamic-user-profile>",
+      "- timezone: Pacific time",
+      "</dynamic-user-profile>",
+    ].join("\n");
     expect(extractUserTimeZoneFromDynamicProfile(profile)).toBeNull();
   });
 
-  test('extracts UTC/GMT offset tokens from explicit timezone profile line', () => {
+  test("extracts UTC/GMT offset tokens from explicit timezone profile line", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- timezone: UTC+2',
-      '</dynamic-user-profile>',
-    ].join('\n');
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Etc/GMT-2');
+      "<dynamic-user-profile>",
+      "- timezone: UTC+2",
+      "</dynamic-user-profile>",
+    ].join("\n");
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Etc/GMT-2");
   });
 
-  test('extracts GMT negative offset tokens from generic profile text', () => {
+  test("extracts GMT negative offset tokens from generic profile text", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- preferences: schedule notifications in GMT-5 whenever possible.',
-      '</dynamic-user-profile>',
-    ].join('\n');
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Etc/GMT+5');
+      "<dynamic-user-profile>",
+      "- preferences: schedule notifications in GMT-5 whenever possible.",
+      "</dynamic-user-profile>",
+    ].join("\n");
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Etc/GMT+5");
   });
 
-  test('extracts fractional UTC offset tokens from explicit timezone profile line', () => {
+  test("extracts fractional UTC offset tokens from explicit timezone profile line", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- timezone: UTC+5:30',
-      '</dynamic-user-profile>',
-    ].join('\n');
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('+05:30');
+      "<dynamic-user-profile>",
+      "- timezone: UTC+5:30",
+      "</dynamic-user-profile>",
+    ].join("\n");
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("+05:30");
   });
 
-  test('extracts fractional GMT offset tokens from generic profile text', () => {
+  test("extracts fractional GMT offset tokens from generic profile text", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- preferences: default reminders to GMT+5:45.',
-      '</dynamic-user-profile>',
-    ].join('\n');
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('+05:45');
+      "<dynamic-user-profile>",
+      "- preferences: default reminders to GMT+5:45.",
+      "</dynamic-user-profile>",
+    ].join("\n");
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("+05:45");
   });
 
-  test('prefers IANA timezone tokens over UTC/GMT offsets in the same profile line', () => {
+  test("prefers IANA timezone tokens over UTC/GMT offsets in the same profile line", () => {
     const profile = [
-      '<dynamic-user-profile>',
-      '- timezone: UTC+1 (Europe/Paris)',
-      '</dynamic-user-profile>',
-    ].join('\n');
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe('Europe/Paris');
+      "<dynamic-user-profile>",
+      "- timezone: UTC+1 (Europe/Paris)",
+      "</dynamic-user-profile>",
+    ].join("\n");
+    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Europe/Paris");
   });
 });
 
@@ -221,17 +232,17 @@ describe('extractUserTimeZoneFromDynamicProfile', () => {
 // Weekday baseline — today is Wednesday
 // ---------------------------------------------------------------------------
 
-describe('weekday baseline (Wednesday)', () => {
-  test('next weekend is the upcoming Saturday-Sunday', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+describe("weekday baseline (Wednesday)", () => {
+  test("next weekend is the upcoming Saturday-Sunday", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
     // Wednesday Feb 18 → next Saturday is Feb 21, Sunday is Feb 22
-    expect(result).toContain('Next weekend: 2026-02-21 – 2026-02-22');
+    expect(result).toContain("Next weekend: 2026-02-21 – 2026-02-22");
   });
 
-  test('next work week is the following Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+  test("next work week is the following Monday-Friday", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
     // Wednesday Feb 18 → next Monday is Feb 23, Friday is Feb 27
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
+    expect(result).toContain("Next work week: 2026-02-23 – 2026-02-27");
   });
 });
 
@@ -239,17 +250,17 @@ describe('weekday baseline (Wednesday)', () => {
 // Weekend baseline — today is Saturday
 // ---------------------------------------------------------------------------
 
-describe('weekend baseline (Saturday)', () => {
-  test('next weekend is the *following* Saturday-Sunday, not today', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
+describe("weekend baseline (Saturday)", () => {
+  test("next weekend is the *following* Saturday-Sunday, not today", () => {
+    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: "UTC" });
     // Saturday Feb 21 → next Saturday is Feb 28, Sunday is Mar 1
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 
-  test('next work week is the upcoming Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
+  test("next work week is the upcoming Monday-Friday", () => {
+    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: "UTC" });
     // Saturday Feb 21 → next Monday is Feb 23, Friday is Feb 27
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
+    expect(result).toContain("Next work week: 2026-02-23 – 2026-02-27");
   });
 });
 
@@ -257,17 +268,17 @@ describe('weekend baseline (Saturday)', () => {
 // Weekend baseline — today is Sunday
 // ---------------------------------------------------------------------------
 
-describe('weekend baseline (Sunday)', () => {
-  test('next weekend is the following Saturday-Sunday', () => {
-    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: 'UTC' });
+describe("weekend baseline (Sunday)", () => {
+  test("next weekend is the following Saturday-Sunday", () => {
+    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: "UTC" });
     // Sunday Feb 22 → next Saturday is Feb 28, Sunday is Mar 1
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 
-  test('next work week is the upcoming Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: 'UTC' });
+  test("next work week is the upcoming Monday-Friday", () => {
+    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: "UTC" });
     // Sunday Feb 22 → next Monday is Feb 23, Friday is Feb 27
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
+    expect(result).toContain("Next work week: 2026-02-23 – 2026-02-27");
   });
 });
 
@@ -275,17 +286,17 @@ describe('weekend baseline (Sunday)', () => {
 // Friday baseline
 // ---------------------------------------------------------------------------
 
-describe('Friday baseline', () => {
-  test('next weekend is tomorrow (Saturday) and Sunday', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
+describe("Friday baseline", () => {
+  test("next weekend is tomorrow (Saturday) and Sunday", () => {
+    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: "UTC" });
     // Friday Feb 27 → next Saturday is Feb 28, Sunday is Mar 1
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 
-  test('next work week is the following Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
+  test("next work week is the following Monday-Friday", () => {
+    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: "UTC" });
     // Friday Feb 27 → next Monday is Mar 2, Friday is Mar 6
-    expect(result).toContain('Next work week: 2026-03-02 – 2026-03-06');
+    expect(result).toContain("Next work week: 2026-03-02 – 2026-03-06");
   });
 });
 
@@ -293,25 +304,29 @@ describe('Friday baseline', () => {
 // Month / year boundary
 // ---------------------------------------------------------------------------
 
-describe('month/year boundary', () => {
-  test('handles year boundary correctly', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC' });
-    expect(result).toContain('Today: 2026-12-29 (Tuesday)');
+describe("month/year boundary", () => {
+  test("handles year boundary correctly", () => {
+    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: "UTC" });
+    expect(result).toContain("Today: 2026-12-29 (Tuesday)");
     // Tuesday Dec 29 → next Saturday is Jan 2 2027
-    expect(result).toContain('Next weekend: 2027-01-02 – 2027-01-03');
+    expect(result).toContain("Next weekend: 2027-01-02 – 2027-01-03");
     // Next Monday is Jan 4 2027 (skips current work week)
     // Wait — Dec 29 is Tuesday, so next Monday = Jan 4? Let me think:
     // Dec 29 Tue → Mon is (1-2+7)%7 = 6 days → Jan 4 Mon
-    expect(result).toContain('Next work week: 2027-01-04 – 2027-01-08');
+    expect(result).toContain("Next work week: 2027-01-04 – 2027-01-08");
   });
 
-  test('horizon entries cross year boundary', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC', horizonDays: 5 });
-    expect(result).toContain('2026-12-30 Wednesday');
-    expect(result).toContain('2026-12-31 Thursday');
-    expect(result).toContain('2027-01-01 Friday');
-    expect(result).toContain('2027-01-02 Saturday');
-    expect(result).toContain('2027-01-03 Sunday');
+  test("horizon entries cross year boundary", () => {
+    const result = buildTemporalContext({
+      nowMs: TUE_DEC_29,
+      timeZone: "UTC",
+      horizonDays: 5,
+    });
+    expect(result).toContain("2026-12-30 Wednesday");
+    expect(result).toContain("2026-12-31 Thursday");
+    expect(result).toContain("2027-01-01 Friday");
+    expect(result).toContain("2027-01-02 Saturday");
+    expect(result).toContain("2027-01-03 Sunday");
   });
 });
 
@@ -319,28 +334,40 @@ describe('month/year boundary', () => {
 // Output size caps
 // ---------------------------------------------------------------------------
 
-describe('output size caps', () => {
-  test('output is at most 1500 characters', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 14 });
+describe("output size caps", () => {
+  test("output is at most 1500 characters", () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "UTC",
+      horizonDays: 14,
+    });
     expect(result.length).toBeLessThanOrEqual(1500);
   });
 
-  test('horizon entries are capped at 14 even if more requested', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 30 });
+  test("horizon entries are capped at 14 even if more requested", () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "UTC",
+      horizonDays: 30,
+    });
     const horizonMatches = result.match(/^\s+\d{4}-\d{2}-\d{2} \w+$/gm);
     expect(horizonMatches).not.toBeNull();
     expect(horizonMatches!.length).toBeLessThanOrEqual(14);
   });
 
-  test('default horizon is 14 days', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+  test("default horizon is 14 days", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
     const horizonMatches = result.match(/^\s+\d{4}-\d{2}-\d{2} \w+$/gm);
     expect(horizonMatches).not.toBeNull();
     expect(horizonMatches!.length).toBe(14);
   });
 
-  test('respects smaller horizonDays', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 3 });
+  test("respects smaller horizonDays", () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "UTC",
+      horizonDays: 3,
+    });
     const horizonMatches = result.match(/^\s+\d{4}-\d{2}-\d{2} \w+$/gm);
     expect(horizonMatches).not.toBeNull();
     expect(horizonMatches!.length).toBe(3);
@@ -351,66 +378,87 @@ describe('output size caps', () => {
 // DST-safe timezone behavior
 // ---------------------------------------------------------------------------
 
-describe('DST-safe timezone behavior', () => {
-  test('date labels are correct in US Eastern timezone', () => {
+describe("DST-safe timezone behavior", () => {
+  test("date labels are correct in US Eastern timezone", () => {
     // Feb 18 12:00 UTC = Feb 18 07:00 EST (same calendar date)
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'America/New_York' });
-    expect(result).toContain('Today: 2026-02-18 (Wednesday)');
-    expect(result).toContain('Current local time: 2026-02-18T07:00:00-05:00');
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "America/New_York",
+    });
+    expect(result).toContain("Today: 2026-02-18 (Wednesday)");
+    expect(result).toContain("Current local time: 2026-02-18T07:00:00-05:00");
   });
 
-  test('date labels are correct in timezone ahead of UTC', () => {
+  test("date labels are correct in timezone ahead of UTC", () => {
     // Use a timestamp near midnight UTC so the local date differs
     // Feb 18 23:00 UTC = Feb 19 08:00 JST
     const nearMidnight = Date.UTC(2026, 1, 18, 23, 0, 0);
-    const result = buildTemporalContext({ nowMs: nearMidnight, timeZone: 'Asia/Tokyo' });
-    expect(result).toContain('Today: 2026-02-19 (Thursday)');
+    const result = buildTemporalContext({
+      nowMs: nearMidnight,
+      timeZone: "Asia/Tokyo",
+    });
+    expect(result).toContain("Today: 2026-02-19 (Thursday)");
   });
 
-  test('addDays is correct across DST spring-forward boundary', () => {
+  test("addDays is correct across DST spring-forward boundary", () => {
     // 2026-03-08 is spring-forward day in America/New_York (clocks jump 2:00→3:00 AM).
     // Use a timestamp at local 23:30 on Friday March 6 (04:30 UTC March 7).
     const preDST = Date.UTC(2026, 2, 7, 4, 30, 0); // local: Fri Mar 6 23:30 EST
-    const result = buildTemporalContext({ nowMs: preDST, timeZone: 'America/New_York', horizonDays: 5 });
+    const result = buildTemporalContext({
+      nowMs: preDST,
+      timeZone: "America/New_York",
+      horizonDays: 5,
+    });
     // Today should be Friday March 6
-    expect(result).toContain('Today: 2026-03-06 (Friday)');
+    expect(result).toContain("Today: 2026-03-06 (Friday)");
     // Horizon should have 5 consecutive days with no duplicates/skips
-    expect(result).toContain('2026-03-07 Saturday');
-    expect(result).toContain('2026-03-08 Sunday');
-    expect(result).toContain('2026-03-09 Monday');
-    expect(result).toContain('2026-03-10 Tuesday');
-    expect(result).toContain('2026-03-11 Wednesday');
+    expect(result).toContain("2026-03-07 Saturday");
+    expect(result).toContain("2026-03-08 Sunday");
+    expect(result).toContain("2026-03-09 Monday");
+    expect(result).toContain("2026-03-10 Tuesday");
+    expect(result).toContain("2026-03-11 Wednesday");
   });
 
-  test('addDays is correct across DST fall-back boundary', () => {
+  test("addDays is correct across DST fall-back boundary", () => {
     // 2026-11-01 is fall-back day in America/New_York (clocks jump 2:00→1:00 AM).
     // Use a timestamp at local 00:30 on Sunday Nov 1 (04:30 UTC Nov 1).
     const preFallback = Date.UTC(2026, 10, 1, 4, 30, 0); // local: Sun Nov 1 00:30 EDT
-    const result = buildTemporalContext({ nowMs: preFallback, timeZone: 'America/New_York', horizonDays: 3 });
+    const result = buildTemporalContext({
+      nowMs: preFallback,
+      timeZone: "America/New_York",
+      horizonDays: 3,
+    });
     // Today should be Sunday Nov 1
-    expect(result).toContain('Today: 2026-11-01 (Sunday)');
+    expect(result).toContain("Today: 2026-11-01 (Sunday)");
     // Horizon should have 3 consecutive days
-    expect(result).toContain('2026-11-02 Monday');
-    expect(result).toContain('2026-11-03 Tuesday');
-    expect(result).toContain('2026-11-04 Wednesday');
+    expect(result).toContain("2026-11-02 Monday");
+    expect(result).toContain("2026-11-03 Tuesday");
+    expect(result).toContain("2026-11-04 Wednesday");
   });
 
-  test('dates are correct in far-east UTC+13 timezone (Pacific/Auckland NZDT)', () => {
+  test("dates are correct in far-east UTC+13 timezone (Pacific/Auckland NZDT)", () => {
     // Feb 18 12:00 UTC = Feb 19 01:00 NZDT (UTC+13 during daylight saving)
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'Pacific/Auckland', horizonDays: 3 });
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "Pacific/Auckland",
+      horizonDays: 3,
+    });
     // In Auckland, Feb 18 12:00 UTC is already Feb 19 (Thursday)
-    expect(result).toContain('Today: 2026-02-19 (Thursday)');
+    expect(result).toContain("Today: 2026-02-19 (Thursday)");
     // Horizon should show consecutive days without +1 shift
-    expect(result).toContain('2026-02-20 Friday');
-    expect(result).toContain('2026-02-21 Saturday');
-    expect(result).toContain('2026-02-22 Sunday');
+    expect(result).toContain("2026-02-20 Friday");
+    expect(result).toContain("2026-02-21 Saturday");
+    expect(result).toContain("2026-02-22 Sunday");
   });
 
-  test('local offset tracks daylight saving changes', () => {
+  test("local offset tracks daylight saving changes", () => {
     // Jul 1 12:00 UTC = Jul 1 08:00 EDT
     const summer = Date.UTC(2026, 6, 1, 12, 0, 0);
-    const result = buildTemporalContext({ nowMs: summer, timeZone: 'America/New_York' });
-    expect(result).toContain('Current local time: 2026-07-01T08:00:00-04:00');
+    const result = buildTemporalContext({
+      nowMs: summer,
+      timeZone: "America/New_York",
+    });
+    expect(result).toContain("Current local time: 2026-07-01T08:00:00-04:00");
   });
 });
 
@@ -418,31 +466,31 @@ describe('DST-safe timezone behavior', () => {
 // Trip-planning regression: "next weekend" resolution
 // ---------------------------------------------------------------------------
 
-describe('trip-planning: next weekend resolution', () => {
+describe("trip-planning: next weekend resolution", () => {
   test('Wednesday → "next weekend" anchors resolve to upcoming Sat-Sun', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
     // A user asking "plan a trip for next weekend" on Wednesday Feb 18
     // expects Sat Feb 21 – Sun Feb 22.
-    expect(result).toContain('Next weekend: 2026-02-21 – 2026-02-22');
+    expect(result).toContain("Next weekend: 2026-02-21 – 2026-02-22");
     // Both dates must appear in the horizon so the model can reference them.
-    expect(result).toContain('2026-02-21 Saturday');
-    expect(result).toContain('2026-02-22 Sunday');
+    expect(result).toContain("2026-02-21 Saturday");
+    expect(result).toContain("2026-02-22 Sunday");
   });
 
   test('Saturday → "next weekend" skips current weekend', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
+    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: "UTC" });
     // Already on Saturday → "next weekend" means the *following* weekend.
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 
   test('Sunday → "next weekend" skips current weekend', () => {
-    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+    const result = buildTemporalContext({ nowMs: SUN_FEB_22, timeZone: "UTC" });
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 
   test('Friday → "next weekend" is tomorrow', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: "UTC" });
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 });
 
@@ -450,22 +498,22 @@ describe('trip-planning: next weekend resolution', () => {
 // Trip-planning regression: "next work week" resolution
 // ---------------------------------------------------------------------------
 
-describe('trip-planning: next work week resolution', () => {
+describe("trip-planning: next work week resolution", () => {
   test('Wednesday → "next work week" skips remainder of current week', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
+    expect(result).toContain("Next work week: 2026-02-23 – 2026-02-27");
   });
 
   test('Monday → "next work week" is the following Monday-Friday', () => {
     /** Monday 2026-02-23 12:00 UTC */
     const MON_FEB_23 = Date.UTC(2026, 1, 23, 12, 0, 0);
-    const result = buildTemporalContext({ nowMs: MON_FEB_23, timeZone: 'UTC' });
-    expect(result).toContain('Next work week: 2026-03-02 – 2026-03-06');
+    const result = buildTemporalContext({ nowMs: MON_FEB_23, timeZone: "UTC" });
+    expect(result).toContain("Next work week: 2026-03-02 – 2026-03-06");
   });
 
   test('Saturday → "next work week" is the upcoming Monday-Friday', () => {
-    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: 'UTC' });
-    expect(result).toContain('Next work week: 2026-02-23 – 2026-02-27');
+    const result = buildTemporalContext({ nowMs: SAT_FEB_21, timeZone: "UTC" });
+    expect(result).toContain("Next work week: 2026-02-23 – 2026-02-27");
   });
 });
 
@@ -473,42 +521,53 @@ describe('trip-planning: next work week resolution', () => {
 // Trip-planning regression: month-without-year disambiguation
 // ---------------------------------------------------------------------------
 
-describe('trip-planning: month-without-year disambiguation via temporal anchors', () => {
-  test('Today line includes full YYYY-MM-DD format with year for month disambiguation', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC' });
+describe("trip-planning: month-without-year disambiguation via temporal anchors", () => {
+  test("Today line includes full YYYY-MM-DD format with year for month disambiguation", () => {
+    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
     // The Today line must include the full year so the model can resolve bare
     // month names (e.g. "May" → May 2026 because today is Feb 2026).
     // Regex ensures YYYY-MM-DD format is present (regression if year is dropped).
     expect(result).toMatch(/Today: \d{4}-\d{2}-\d{2} \(\w+\)/);
-    expect(result).toContain('2026-02-18');
+    expect(result).toContain("2026-02-18");
   });
 
-  test('future-month anchors: horizon dates are all in the future relative to today', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'UTC', horizonDays: 14 });
+  test("future-month anchors: horizon dates are all in the future relative to today", () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "UTC",
+      horizonDays: 14,
+    });
     // Extract all horizon dates (indented YYYY-MM-DD lines)
     const horizonDates = result.match(/^\s+(\d{4}-\d{2}-\d{2}) \w+$/gm);
     expect(horizonDates).not.toBeNull();
     // All horizon dates must be after today (2026-02-18)
     for (const line of horizonDates!) {
-      const dateStr = line.trim().split(' ')[0];
-      expect(dateStr > '2026-02-18').toBe(true);
+      const dateStr = line.trim().split(" ")[0];
+      expect(dateStr > "2026-02-18").toBe(true);
     }
   });
 
-  test('year-end context: horizon spans into next year for Dec disambiguation', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC', horizonDays: 14 });
+  test("year-end context: horizon spans into next year for Dec disambiguation", () => {
+    const result = buildTemporalContext({
+      nowMs: TUE_DEC_29,
+      timeZone: "UTC",
+      horizonDays: 14,
+    });
     // Today is Dec 29 2026 — horizon must include 2027 dates so the model can
     // distinguish "January" (Jan 2027) from past January (Jan 2026).
-    expect(result).toContain('Today: 2026-12-29');
+    expect(result).toContain("Today: 2026-12-29");
     expect(result).toMatch(/2027-01-\d{2} \w+/); // At least one January 2027 date
   });
 
-  test('timezone is always present for correct local-month resolution', () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: 'America/New_York' });
+  test("timezone is always present for correct local-month resolution", () => {
+    const result = buildTemporalContext({
+      nowMs: WED_FEB_18,
+      timeZone: "America/New_York",
+    });
     // Timezone must be present so the model resolves months in the user's
     // local calendar, not UTC.
     expect(result).toMatch(/Timezone: .+/);
-    expect(result).toContain('America/New_York');
+    expect(result).toContain("America/New_York");
   });
 });
 
@@ -516,15 +575,15 @@ describe('trip-planning: month-without-year disambiguation via temporal anchors'
 // Trip-planning regression: cross-month weekend resolution
 // ---------------------------------------------------------------------------
 
-describe('trip-planning: cross-month weekend resolution', () => {
-  test('weekend that spans a month boundary (Feb → Mar)', () => {
-    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+describe("trip-planning: cross-month weekend resolution", () => {
+  test("weekend that spans a month boundary (Feb → Mar)", () => {
+    const result = buildTemporalContext({ nowMs: FRI_FEB_27, timeZone: "UTC" });
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 
-  test('year-boundary weekend (Dec 2026 → Jan 2027)', () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: 'UTC' });
-    expect(result).toContain('Next weekend: 2027-01-02 – 2027-01-03');
+  test("year-boundary weekend (Dec 2026 → Jan 2027)", () => {
+    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: "UTC" });
+    expect(result).toContain("Next weekend: 2027-01-02 – 2027-01-03");
   });
 });
 
@@ -532,21 +591,27 @@ describe('trip-planning: cross-month weekend resolution', () => {
 // Trip-planning regression: timezone-shifted weekend anchors
 // ---------------------------------------------------------------------------
 
-describe('trip-planning: timezone-shifted weekend anchors', () => {
-  test('late Friday UTC is already Saturday in Auckland → skips to next weekend', () => {
+describe("trip-planning: timezone-shifted weekend anchors", () => {
+  test("late Friday UTC is already Saturday in Auckland → skips to next weekend", () => {
     // Friday Feb 27 23:00 UTC = Saturday Feb 28 12:00 NZDT
     const lateFriUTC = Date.UTC(2026, 1, 27, 23, 0, 0);
-    const result = buildTemporalContext({ nowMs: lateFriUTC, timeZone: 'Pacific/Auckland' });
-    expect(result).toContain('Today: 2026-02-28 (Saturday)');
+    const result = buildTemporalContext({
+      nowMs: lateFriUTC,
+      timeZone: "Pacific/Auckland",
+    });
+    expect(result).toContain("Today: 2026-02-28 (Saturday)");
     // "Next weekend" skips current weekend → Mar 7-8.
-    expect(result).toContain('Next weekend: 2026-03-07 – 2026-03-08');
+    expect(result).toContain("Next weekend: 2026-03-07 – 2026-03-08");
   });
 
-  test('early Saturday UTC is still Friday in US Pacific → next weekend is tomorrow', () => {
+  test("early Saturday UTC is still Friday in US Pacific → next weekend is tomorrow", () => {
     // Saturday Feb 28 02:00 UTC = Friday Feb 27 18:00 PST
     const earlySatUTC = Date.UTC(2026, 1, 28, 2, 0, 0);
-    const result = buildTemporalContext({ nowMs: earlySatUTC, timeZone: 'America/Los_Angeles' });
-    expect(result).toContain('Today: 2026-02-27 (Friday)');
-    expect(result).toContain('Next weekend: 2026-02-28 – 2026-03-01');
+    const result = buildTemporalContext({
+      nowMs: earlySatUTC,
+      timeZone: "America/Los_Angeles",
+    });
+    expect(result).toContain("Today: 2026-02-27 (Friday)");
+    expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 });