refactor: rename arktype schemas to match types

Co-authored-by: Ona <no-reply@ona.com>

apps/aris-backend/.env.example

@@ -7,6 +7,11 @@ BETTER_AUTH_SECRET=
 # Base URL of the backend
 BETTER_AUTH_URL=http://localhost:3000
 
+# OpenRouter (LLM feed enhancement)
+OPENROUTER_API_KEY=
+# Optional: override the default model (default: openai/gpt-4.1-mini)
+# OPENROUTER_MODEL=openai/gpt-4.1-mini
+
 # Apple WeatherKit credentials
 WEATHERKIT_PRIVATE_KEY=
 WEATHERKIT_KEY_ID=

apps/aris-backend/package.json

@@ -10,9 +10,12 @@
 	},
 	"dependencies": {
 		"@aris/core": "workspace:*",
+		"@aris/source-caldav": "workspace:*",
+		"@aris/source-google-calendar": "workspace:*",
 		"@aris/source-location": "workspace:*",
 		"@aris/source-tfl": "workspace:*",
 		"@aris/source-weatherkit": "workspace:*",
+		"@openrouter/sdk": "^0.9.11",
 		"arktype": "^2.1.29",
 		"better-auth": "^1",
 		"hono": "^4",

apps/aris-backend/src/enhancement/enhance-feed.ts

@@ -0,0 +1,51 @@
+import type { FeedItem } from "@aris/core"
+
+import type { LlmClient } from "./llm-client.ts"
+
+import { mergeEnhancement } from "./merge.ts"
+import { buildPrompt, hasUnfilledSlots } from "./prompt-builder.ts"
+
+/** Takes feed items, returns enhanced feed items. */
+export type FeedEnhancer = (items: FeedItem[]) => Promise<FeedItem[]>
+
+export interface FeedEnhancerConfig {
+	client: LlmClient
+	/** Defaults to Date.now — override for testing */
+	clock?: () => Date
+}
+
+/**
+ * Creates a FeedEnhancer that uses the provided LlmClient.
+ *
+ * Skips the LLM call when no items have unfilled slots.
+ * Returns items unchanged on LLM failure.
+ */
+export function createFeedEnhancer(config: FeedEnhancerConfig): FeedEnhancer {
+	const { client } = config
+	const clock = config.clock ?? (() => new Date())
+
+	return async function enhanceFeed(items) {
+		if (!hasUnfilledSlots(items)) {
+			return items
+		}
+
+		const currentTime = clock()
+		const { systemPrompt, userMessage } = buildPrompt(items, currentTime)
+
+		let result
+		try {
+			result = await client.enhance({ systemPrompt, userMessage })
+		} catch (err) {
+			console.error("[enhancement] LLM call failed:", err)
+			result = null
+		}
+
+		if (!result) {
+			return items
+		}
+
+		return mergeEnhancement(items, result, currentTime)
+	}
+}
+
+

apps/aris-backend/src/enhancement/llm-client.ts

@@ -0,0 +1,71 @@
+import { OpenRouter } from "@openrouter/sdk"
+
+import type { EnhancementResult } from "./schema.ts"
+
+import { enhancementResultJsonSchema, parseEnhancementResult } from "./schema.ts"
+
+const DEFAULT_MODEL = "openai/gpt-4.1-mini"
+const DEFAULT_TIMEOUT_MS = 30_000
+
+export interface LlmClientConfig {
+	apiKey: string
+	model?: string
+	timeoutMs?: number
+}
+
+export interface LlmClientRequest {
+	systemPrompt: string
+	userMessage: string
+}
+
+export interface LlmClient {
+	enhance(request: LlmClientRequest): Promise<EnhancementResult | null>
+}
+
+/**
+ * Creates a reusable LLM client backed by OpenRouter.
+ * The OpenRouter SDK instance is created once and reused across calls.
+ */
+export function createLlmClient(config: LlmClientConfig): LlmClient {
+	const client = new OpenRouter({
+		apiKey: config.apiKey,
+		timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+	})
+	const model = config.model ?? DEFAULT_MODEL
+
+	return {
+		async enhance(request) {
+			const response = await client.chat.send({
+				chatGenerationParams: {
+					model,
+					messages: [
+						{ role: "system" as const, content: request.systemPrompt },
+						{ role: "user" as const, content: request.userMessage },
+					],
+					responseFormat: {
+						type: "json_schema" as const,
+						jsonSchema: {
+							name: "enhancement_result",
+							strict: true,
+							schema: enhancementResultJsonSchema,
+						},
+					},
+					stream: false,
+				},
+			})
+
+			const content = response.choices?.[0]?.message?.content
+			if (typeof content !== "string") {
+				console.warn("[enhancement] LLM returned no content in response")
+				return null
+			}
+
+			const result = parseEnhancementResult(content)
+			if (!result) {
+				console.warn("[enhancement] Failed to parse LLM response:", content)
+			}
+
+			return result
+		},
+	}
+}

apps/aris-backend/src/enhancement/merge.test.ts

@@ -0,0 +1,150 @@
+import type { FeedItem } from "@aris/core"
+
+import { describe, expect, test } from "bun:test"
+
+import type { EnhancementResult } from "./schema.ts"
+
+import { mergeEnhancement } from "./merge.ts"
+
+function makeItem(overrides: Partial<FeedItem> = {}): FeedItem {
+	return {
+		id: "item-1",
+		type: "test",
+		timestamp: new Date("2025-01-01T00:00:00Z"),
+		data: { value: 42 },
+		...overrides,
+	}
+}
+
+const now = new Date("2025-06-01T12:00:00Z")
+
+describe("mergeEnhancement", () => {
+	test("fills matching slots", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "Weather insight", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: {
+				"item-1": { insight: "Rain after 3pm" },
+			},
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(1)
+		expect(merged[0]!.slots!.insight!.content).toBe("Rain after 3pm")
+		// Description preserved
+		expect(merged[0]!.slots!.insight!.description).toBe("Weather insight")
+	})
+
+	test("does not mutate original items", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: { "item-1": { insight: "filled" } },
+			syntheticItems: [],
+		}
+
+		mergeEnhancement([item], result, now)
+
+		expect(item.slots!.insight!.content).toBeNull()
+	})
+
+	test("ignores fills for non-existent items", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: { "non-existent": { insight: "text" } },
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(1)
+		expect(merged[0]!.id).toBe("item-1")
+	})
+
+	test("ignores fills for non-existent slots", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: { "item-1": { "non-existent-slot": "text" } },
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged[0]!.slots!.insight!.content).toBeNull()
+	})
+
+	test("skips null fills", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: { "item-1": { insight: null } },
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged[0]!.slots!.insight!.content).toBeNull()
+	})
+
+	test("passes through items without slots unchanged", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: {},
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged[0]).toBe(item)
+	})
+
+	test("appends synthetic items with backfilled fields", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: {},
+			syntheticItems: [
+				{
+					id: "briefing-morning",
+					type: "briefing",
+					text: "Light afternoon ahead.",
+				},
+			],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(2)
+		expect(merged[1]!.id).toBe("briefing-morning")
+		expect(merged[1]!.type).toBe("briefing")
+		expect(merged[1]!.timestamp).toEqual(now)
+		expect(merged[1]!.data).toEqual({ text: "Light afternoon ahead." })
+	})
+
+	test("handles empty enhancement result", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: {},
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(1)
+		expect(merged[0]).toBe(item)
+	})
+})

apps/aris-backend/src/enhancement/merge.ts

@@ -0,0 +1,41 @@
+import type { FeedItem } from "@aris/core"
+
+import type { EnhancementResult } from "./schema.ts"
+
+/**
+ * Merges an EnhancementResult into feed items.
+ *
+ * - Writes slot content from slotFills into matching items
+ * - Appends synthetic items to the list
+ * - Returns a new array (no mutation)
+ * - Ignores fills for items/slots that don't exist
+ */
+export function mergeEnhancement(items: FeedItem[], result: EnhancementResult, currentTime: Date): FeedItem[] {
+	const merged = items.map((item) => {
+		const fills = result.slotFills[item.id]
+		if (!fills || !item.slots) return item
+
+		const mergedSlots = { ...item.slots }
+		let changed = false
+
+		for (const [slotName, content] of Object.entries(fills)) {
+			if (slotName in mergedSlots && content !== null) {
+				mergedSlots[slotName] = { ...mergedSlots[slotName]!, content }
+				changed = true
+			}
+		}
+
+		return changed ? { ...item, slots: mergedSlots } : item
+	})
+
+	for (const synthetic of result.syntheticItems) {
+		merged.push({
+			id: synthetic.id,
+			type: synthetic.type,
+			timestamp: currentTime,
+			data: { text: synthetic.text },
+		})
+	}
+
+	return merged
+}

apps/aris-backend/src/enhancement/prompt-builder.test.ts

@@ -0,0 +1,167 @@
+import type { FeedItem } from "@aris/core"
+
+import { describe, expect, test } from "bun:test"
+
+import { buildPrompt, hasUnfilledSlots } from "./prompt-builder.ts"
+
+function makeItem(overrides: Partial<FeedItem> = {}): FeedItem {
+	return {
+		id: "item-1",
+		type: "test",
+		timestamp: new Date("2025-01-01T00:00:00Z"),
+		data: { value: 42 },
+		...overrides,
+	}
+}
+
+function parseUserMessage(userMessage: string): Record<string, unknown> {
+	return JSON.parse(userMessage)
+}
+
+describe("hasUnfilledSlots", () => {
+	test("returns false for items without slots", () => {
+		expect(hasUnfilledSlots([makeItem()])).toBe(false)
+	})
+
+	test("returns false for items with all slots filled", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: "filled" },
+			},
+		})
+		expect(hasUnfilledSlots([item])).toBe(false)
+	})
+
+	test("returns true when at least one slot is unfilled", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		expect(hasUnfilledSlots([item])).toBe(true)
+	})
+
+	test("returns false for empty array", () => {
+		expect(hasUnfilledSlots([])).toBe(false)
+	})
+})
+
+describe("buildPrompt", () => {
+	test("puts items with unfilled slots in items", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "Weather insight", content: null },
+				filled: { description: "Already done", content: "done" },
+			},
+		})
+
+		const { userMessage } = buildPrompt([item], new Date("2025-06-01T12:00:00Z"))
+		const parsed = parseUserMessage(userMessage)
+
+		expect(parsed.items).toHaveLength(1)
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.id).toBe("item-1")
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.slots).toEqual({ insight: "Weather insight" })
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.type).toBeUndefined()
+		expect(parsed.context).toHaveLength(0)
+	})
+
+	test("puts slotless items in context", () => {
+		const withSlots = makeItem({
+			id: "with-slots",
+			slots: { insight: { description: "test", content: null } },
+		})
+		const withoutSlots = makeItem({ id: "no-slots" })
+
+		const { userMessage } = buildPrompt([withSlots, withoutSlots], new Date("2025-06-01T12:00:00Z"))
+		const parsed = parseUserMessage(userMessage)
+
+		expect(parsed.items).toHaveLength(1)
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.id).toBe("with-slots")
+		expect(parsed.context).toHaveLength(1)
+		expect((parsed.context as Array<Record<string, unknown>>)[0]!.id).toBe("no-slots")
+	})
+
+	test("includes time in ISO format", () => {
+		const { userMessage } = buildPrompt([], new Date("2025-06-01T12:00:00Z"))
+		const parsed = parseUserMessage(userMessage)
+
+		expect(parsed.time).toBe("2025-06-01T12:00:00.000Z")
+	})
+
+	test("system prompt is non-empty", () => {
+		const { systemPrompt } = buildPrompt([], new Date())
+		expect(systemPrompt.length).toBeGreaterThan(0)
+	})
+
+	test("includes schedule in system prompt", () => {
+		const calEvent = makeItem({
+			id: "cal-1",
+			type: "caldav-event",
+			data: {
+				title: "Team standup",
+				startDate: "2025-06-01T10:00:00Z",
+				endDate: "2025-06-01T10:30:00Z",
+				isAllDay: false,
+				location: null,
+			},
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+
+		const { systemPrompt } = buildPrompt([calEvent], new Date("2025-06-01T12:00:00Z"))
+
+		expect(systemPrompt).toContain("Schedule:\n")
+		expect(systemPrompt).toContain("Team standup")
+		expect(systemPrompt).toContain("10:00")
+	})
+
+	test("includes location in schedule", () => {
+		const calEvent = makeItem({
+			id: "cal-1",
+			type: "caldav-event",
+			data: {
+				title: "Therapy",
+				startDate: "2025-06-02T18:00:00Z",
+				endDate: "2025-06-02T19:00:00Z",
+				isAllDay: false,
+				location: "92 Tooley Street, London",
+			},
+		})
+
+		const { systemPrompt } = buildPrompt([calEvent], new Date("2025-06-01T12:00:00Z"))
+
+		expect(systemPrompt).toContain("Therapy @ 92 Tooley Street, London")
+	})
+
+	test("includes week calendar but omits schedule when no calendar items", () => {
+		const weatherItem = makeItem({
+			type: "weather-current",
+			data: { temperature: 14 },
+		})
+
+		const { systemPrompt } = buildPrompt([weatherItem], new Date("2025-06-01T12:00:00Z"))
+
+		expect(systemPrompt).toContain("Week:")
+		expect(systemPrompt).not.toContain("Schedule:")
+	})
+
+	test("user message is pure JSON", () => {
+		const calEvent = makeItem({
+			id: "cal-1",
+			type: "caldav-event",
+			data: {
+				title: "Budget Review",
+				startTime: "2025-06-01T14:00:00Z",
+				endTime: "2025-06-01T15:00:00Z",
+				isAllDay: false,
+				location: "https://meet.google.com/abc",
+			},
+		})
+
+		const { userMessage } = buildPrompt([calEvent], new Date("2025-06-01T12:00:00Z"))
+
+		expect(userMessage.startsWith("{")).toBe(true)
+		expect(() => JSON.parse(userMessage)).not.toThrow()
+	})
+})

apps/aris-backend/src/enhancement/prompt-builder.ts

@@ -0,0 +1,218 @@
+import type { FeedItem } from "@aris/core"
+
+import { CalDavFeedItemType } from "@aris/source-caldav"
+import { CalendarFeedItemType } from "@aris/source-google-calendar"
+
+import systemPromptBase from "./prompts/system.txt"
+
+const CALENDAR_ITEM_TYPES = new Set<string>([
+	CalDavFeedItemType.Event,
+	CalendarFeedItemType.Event,
+	CalendarFeedItemType.AllDay,
+])
+
+/**
+ * Builds the system prompt and user message for the enhancement harness.
+ *
+ * Includes a pre-computed mini calendar so the LLM doesn't have to
+ * parse timestamps to understand the user's schedule.
+ */
+export function buildPrompt(
+	items: FeedItem[],
+	currentTime: Date,
+): { systemPrompt: string; userMessage: string } {
+	const schedule = buildSchedule(items, currentTime)
+
+	const enhanceItems: Array<{
+		id: string
+		data: Record<string, unknown>
+		slots: Record<string, string>
+	}> = []
+	const contextItems: Array<{
+		id: string
+		type: string
+		data: Record<string, unknown>
+	}> = []
+
+	for (const item of items) {
+		const hasUnfilledSlots =
+			item.slots &&
+			Object.values(item.slots).some((slot) => slot.content === null)
+
+		if (hasUnfilledSlots) {
+			enhanceItems.push({
+				id: item.id,
+				data: item.data,
+				slots: Object.fromEntries(
+					Object.entries(item.slots!)
+						.filter(([, slot]) => slot.content === null)
+						.map(([name, slot]) => [name, slot.description]),
+				),
+			})
+		} else {
+			contextItems.push({
+				id: item.id,
+				type: item.type,
+				data: item.data,
+			})
+		}
+	}
+
+	const userMessage = JSON.stringify({
+		time: currentTime.toISOString(),
+		items: enhanceItems,
+		context: contextItems,
+	})
+
+	const weekCalendar = buildWeekCalendar(currentTime)
+	let systemPrompt = systemPromptBase
+	systemPrompt += `\n\nWeek:\n${weekCalendar}`
+	if (schedule) {
+		systemPrompt += `\n\nSchedule:\n${schedule}`
+	}
+
+	return { systemPrompt, userMessage }
+}
+
+/**
+ * Returns true if any item has at least one unfilled slot.
+ */
+export function hasUnfilledSlots(items: FeedItem[]): boolean {
+	return items.some(
+		(item) =>
+			item.slots &&
+			Object.values(item.slots).some((slot) => slot.content === null),
+	)
+}
+
+// -- Helpers --
+
+interface CalendarEntry {
+	date: Date
+	title: string
+	location: string | null
+	isAllDay: boolean
+	startTime: Date
+	endTime: Date
+}
+
+function toValidDate(value: unknown): Date | null {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value
+	if (typeof value === "string" || typeof value === "number") {
+		const date = new Date(value)
+		return Number.isNaN(date.getTime()) ? null : date
+	}
+	return null
+}
+
+function extractCalendarEntry(item: FeedItem): CalendarEntry | null {
+	if (!CALENDAR_ITEM_TYPES.has(item.type)) return null
+
+	const d = item.data
+	const title = d.title
+	if (typeof title !== "string" || !title) return null
+
+	// CalDAV uses startDate/endDate, Google Calendar uses startTime/endTime
+	const startTime = toValidDate(d.startDate ?? d.startTime)
+	if (!startTime) return null
+
+	const endTime = toValidDate(d.endDate ?? d.endTime) ?? startTime
+
+	return {
+		date: startTime,
+		title,
+		location: typeof d.location === "string" ? d.location : null,
+		isAllDay: typeof d.isAllDay === "boolean" ? d.isAllDay : false,
+		startTime,
+		endTime,
+	}
+}
+
+const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const
+
+function pad2(n: number): string {
+	return n.toString().padStart(2, "0")
+}
+
+function formatTime(date: Date): string {
+	return `${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}`
+}
+
+function formatDayShort(date: Date): string {
+	return `${DAYS[date.getUTCDay()]}, ${date.getUTCDate()} ${MONTHS[date.getUTCMonth()]}`
+}
+
+function formatDayLabel(date: Date, currentTime: Date): string {
+	const currentDay = Date.UTC(currentTime.getUTCFullYear(), currentTime.getUTCMonth(), currentTime.getUTCDate())
+	const targetDay = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate())
+	const diffDays = Math.round((targetDay - currentDay) / (1000 * 60 * 60 * 24))
+
+	const dayName = formatDayShort(date)
+
+	if (diffDays === 0) return `Today: ${dayName}`
+	if (diffDays === 1) return `Tomorrow: ${dayName}`
+	return dayName
+}
+
+/**
+ * Builds a week overview mapping day names to dates,
+ * so the LLM can easily match ISO timestamps to days.
+ */
+function buildWeekCalendar(currentTime: Date): string {
+	const lines: string[] = []
+	for (let i = 0; i < 7; i++) {
+		const date = new Date(currentTime)
+		date.setUTCDate(date.getUTCDate() + i)
+		const label = i === 0 ? "Today" : i === 1 ? "Tomorrow" : ""
+		const dayStr = formatDayShort(date)
+		const iso = date.toISOString().slice(0, 10)
+		const prefix = label ? `${label}: ` : ""
+		lines.push(`${prefix}${dayStr} = ${iso}`)
+	}
+	return lines.join("\n")
+}
+
+/**
+ * Builds a compact text calendar from all calendar-type items.
+ * Groups events by day relative to currentTime.
+ */
+function buildSchedule(items: FeedItem[], currentTime: Date): string {
+	const entries: CalendarEntry[] = []
+	for (const item of items) {
+		const entry = extractCalendarEntry(item)
+		if (entry) entries.push(entry)
+	}
+
+	if (entries.length === 0) return ""
+
+	entries.sort((a, b) => a.startTime.getTime() - b.startTime.getTime())
+
+	const byDay = new Map<string, CalendarEntry[]>()
+	for (const entry of entries) {
+		const key = entry.date.toISOString().slice(0, 10)
+		const group = byDay.get(key)
+		if (group) {
+			group.push(entry)
+		} else {
+			byDay.set(key, [entry])
+		}
+	}
+
+	const lines: string[] = []
+	for (const [, dayEntries] of byDay) {
+		lines.push(formatDayLabel(dayEntries[0]!.startTime, currentTime))
+		for (const entry of dayEntries) {
+			if (entry.isAllDay) {
+				const loc = entry.location ? ` @ ${entry.location}` : ""
+				lines.push(`  all day  ${entry.title}${loc}`)
+			} else {
+				const timeRange = `${formatTime(entry.startTime)}–${formatTime(entry.endTime)}`
+				const loc = entry.location ? ` @ ${entry.location}` : ""
+				lines.push(`  ${timeRange}  ${entry.title}${loc}`)
+			}
+		}
+	}
+
+	return lines.join("\n")
+}

apps/aris-backend/src/enhancement/prompts/system.txt

@@ -0,0 +1,21 @@
+You are ARIS, a personal assistant. You enhance a user's feed by filling slots and optionally generating synthetic items.
+
+The user message is a JSON object with:
+- "items": feed items with data and named slots to fill. Each slot has a description of what to write.
+- "context": other feed items (no slots) for cross-source reasoning.
+- "time": current ISO timestamp.
+
+Your output has two fields:
+- "slotFills": map of item ID → slot name → short text (or null if you can't fill it or cannot provide answer). Each item ID appears ONCE with ALL its slots in a single object.
+- "syntheticItems": array of { id, type, text } for new items (briefings, nudges, insights). Only when genuinely useful and when not redundant.
+
+Rules:
+- DO NOT USE EMDASH OR DASH OR ATTEMPT TO USE SYMBOLS TO CIRCUMVENT THIS RULE.
+- One sentence per slot. Two max if absolutely necessary. Be direct.
+- Say "I" not "we."
+- Hedge when inferring. Don't state guesses as facts.
+- Use the week and schedule below to understand when events happen. Match weather data to the correct date.
+- Look for connections across items.
+- Don't pad — return null for slots you can't meaningfully fill, and skip synthetic items if there's nothing useful to add.
+- Never fabricate information not present in the feed. If you don't have data to support a fill, return null.
+- Read each slot's description carefully — it defines when to return null.

apps/aris-backend/src/enhancement/schema.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, test } from "bun:test"
+
+import {
+	emptyEnhancementResult,
+	enhancementResultJsonSchema,
+	parseEnhancementResult,
+} from "./schema.ts"
+
+describe("parseEnhancementResult", () => {
+	test("parses valid result", () => {
+		const input = JSON.stringify({
+			slotFills: {
+				"weather-1": {
+					insight: "Rain after 3pm",
+					"cross-source": null,
+				},
+			},
+			syntheticItems: [
+				{
+					id: "briefing-morning",
+					type: "briefing",
+					text: "Light afternoon ahead.",
+				},
+			],
+		})
+
+		const result = parseEnhancementResult(input)
+
+		expect(result).not.toBeNull()
+		expect(result!.slotFills["weather-1"]!.insight).toBe("Rain after 3pm")
+		expect(result!.slotFills["weather-1"]!["cross-source"]).toBeNull()
+		expect(result!.syntheticItems).toHaveLength(1)
+		expect(result!.syntheticItems[0]!.id).toBe("briefing-morning")
+		expect(result!.syntheticItems[0]!.text).toBe("Light afternoon ahead.")
+	})
+
+	test("parses empty result", () => {
+		const input = JSON.stringify({
+			slotFills: {},
+			syntheticItems: [],
+		})
+
+		const result = parseEnhancementResult(input)
+
+		expect(result).not.toBeNull()
+		expect(Object.keys(result!.slotFills)).toHaveLength(0)
+		expect(result!.syntheticItems).toHaveLength(0)
+	})
+
+	test("returns null for invalid JSON", () => {
+		expect(parseEnhancementResult("not json")).toBeNull()
+	})
+
+	test("returns null for non-object", () => {
+		expect(parseEnhancementResult('"hello"')).toBeNull()
+		expect(parseEnhancementResult("42")).toBeNull()
+		expect(parseEnhancementResult("null")).toBeNull()
+	})
+
+	test("returns null when slotFills is missing", () => {
+		const input = JSON.stringify({ syntheticItems: [] })
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+
+	test("returns null when syntheticItems is missing", () => {
+		const input = JSON.stringify({ slotFills: {} })
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+
+	test("returns null when slotFills has non-string values", () => {
+		const input = JSON.stringify({
+			slotFills: { "item-1": { slot: 42 } },
+			syntheticItems: [],
+		})
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+
+	test("returns null when syntheticItem is missing required fields", () => {
+		const input = JSON.stringify({
+			slotFills: {},
+			syntheticItems: [{ id: "x" }],
+		})
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+})
+
+describe("emptyEnhancementResult", () => {
+	test("returns empty slotFills and syntheticItems", () => {
+		const result = emptyEnhancementResult()
+		expect(result.slotFills).toEqual({})
+		expect(result.syntheticItems).toEqual([])
+	})
+})
+
+describe("schema sync", () => {
+	const referencePayloads = [
+		{
+			name: "full payload with null slot fill",
+			payload: {
+				slotFills: {
+					"weather-1": { insight: "Rain after 3pm", crossSource: null },
+					"cal-2": { summary: "Busy morning" },
+				},
+				syntheticItems: [
+					{ id: "briefing-morning", type: "briefing", text: "Light day ahead." },
+					{ id: "nudge-umbrella", type: "nudge", text: "Bring an umbrella." },
+				],
+			},
+		},
+		{
+			name: "empty collections",
+			payload: { slotFills: {}, syntheticItems: [] },
+		},
+		{
+			name: "slot fills only",
+			payload: {
+				slotFills: { "item-1": { slot: "filled" } },
+				syntheticItems: [],
+			},
+		},
+		{
+			name: "synthetic items only",
+			payload: {
+				slotFills: {},
+				syntheticItems: [{ id: "insight-1", type: "insight", text: "Something." }],
+			},
+		},
+	]
+
+	for (const { name, payload } of referencePayloads) {
+		test(`arktype and JSON Schema agree on: ${name}`, () => {
+			// arktype accepts it
+			const parsed = parseEnhancementResult(JSON.stringify(payload))
+			expect(parsed).not.toBeNull()
+
+			// JSON Schema structure matches
+			const jsonSchema = enhancementResultJsonSchema
+			expect(Object.keys(jsonSchema.properties).sort()).toEqual(
+				Object.keys(payload).sort(),
+			)
+			expect([...jsonSchema.required].sort()).toEqual(Object.keys(payload).sort())
+
+			// syntheticItems item schema has the right required fields
+			const itemSchema = jsonSchema.properties.syntheticItems.items
+			expect([...itemSchema.required].sort()).toEqual(["id", "text", "type"])
+
+			// Verify each synthetic item has exactly the fields the JSON Schema expects
+			for (const item of payload.syntheticItems) {
+				expect(Object.keys(item).sort()).toEqual([...itemSchema.required].sort())
+			}
+		})
+	}
+
+	test("JSON Schema rejects what arktype rejects: missing required field", () => {
+		// Missing syntheticItems
+		expect(parseEnhancementResult(JSON.stringify({ slotFills: {} }))).toBeNull()
+
+		// JSON Schema also requires it
+		expect(enhancementResultJsonSchema.required).toContain("syntheticItems")
+	})
+
+	test("JSON Schema rejects what arktype rejects: wrong slot fill value type", () => {
+		const bad = { slotFills: { "item-1": { slot: 42 } }, syntheticItems: [] }
+
+		// arktype rejects it
+		expect(parseEnhancementResult(JSON.stringify(bad))).toBeNull()
+
+		// JSON Schema only allows string or null for slot values
+		const slotValueTypes =
+			enhancementResultJsonSchema.properties.slotFills.additionalProperties
+				.additionalProperties.type
+		expect(slotValueTypes).toContain("string")
+		expect(slotValueTypes).toContain("null")
+		expect(slotValueTypes).not.toContain("number")
+	})
+})

apps/aris-backend/src/enhancement/schema.ts

@@ -0,0 +1,89 @@
+import { type } from "arktype"
+
+const SyntheticItem = type({
+	id: "string",
+	type: "string",
+	text: "string",
+})
+
+const EnhancementResult = type({
+	slotFills: "Record<string, Record<string, string | null>>",
+	syntheticItems: SyntheticItem.array(),
+})
+
+export type SyntheticItem = typeof SyntheticItem.infer
+export type EnhancementResult = typeof EnhancementResult.infer
+
+/**
+ * JSON Schema passed to OpenRouter's structured output.
+ * OpenRouter doesn't support arktype, so this is maintained separately.
+ *
+ * ⚠️  Must stay in sync with EnhancementResult above.
+ * If you add/remove fields, update both schemas.
+ */
+export const enhancementResultJsonSchema = {
+	type: "object",
+	properties: {
+		slotFills: {
+			type: "object",
+			description:
+				"Map of feed item ID to an object of slot name to filled text content. Use null for slots that cannot be meaningfully filled.",
+			additionalProperties: {
+				type: "object",
+				additionalProperties: {
+					type: ["string", "null"],
+				},
+			},
+		},
+		syntheticItems: {
+			type: "array",
+			description:
+				"New feed items to inject (briefings, nudges, cross-source insights). Keep these short and actionable.",
+			items: {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						description: "Unique ID, e.g. 'briefing-morning'",
+					},
+					type: {
+						type: "string",
+						description: "One of: 'briefing', 'nudge', 'insight'",
+					},
+					text: {
+						type: "string",
+						description: "Display text, 1-3 sentences",
+					},
+				},
+				required: ["id", "type", "text"],
+				additionalProperties: false,
+			},
+		},
+	},
+	required: ["slotFills", "syntheticItems"],
+	additionalProperties: false,
+} as const
+
+/**
+ * Parses a JSON string into an EnhancementResult.
+ * Returns null if the input is malformed.
+ */
+export function parseEnhancementResult(json: string): EnhancementResult | null {
+	let parsed: unknown
+	try {
+		parsed = JSON.parse(json)
+	} catch {
+		return null
+	}
+
+	const result = EnhancementResult(parsed)
+	if (result instanceof type.errors) {
+		return null
+	}
+
+	return result
+}
+
+export function emptyEnhancementResult(): EnhancementResult {
+	return { slotFills: {}, syntheticItems: [] }
+}

apps/aris-backend/src/feed/http.test.ts

@@ -1,4 +1,4 @@
-import type { ActionDefinition, Context, FeedItem, FeedSource } from "@aris/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aris/core"
 
 import { describe, expect, test } from "bun:test"
 import { Hono } from "hono"
@@ -27,7 +27,7 @@ function createStubSource(id: string, items: FeedItem[] = []): FeedSource {
 		async executeAction(): Promise<unknown> {
 			return undefined
 		},
-		async fetchContext(): Promise<Partial<Context> | null> {
+		async fetchContext(): Promise<readonly ContextEntry[] | null> {
 			return null
 		},
 		async fetchItems() {
@@ -47,7 +47,7 @@ function buildTestApp(sessionManager: UserSessionManager, userId?: string) {
 
 describe("GET /api/feed", () => {
 	test("returns 401 without auth", async () => {
-		const manager = new UserSessionManager([])
+		const manager = new UserSessionManager({ providers: [] })
 		const app = buildTestApp(manager)
 
 		const res = await app.request("/api/feed")
@@ -65,7 +65,9 @@ describe("GET /api/feed", () => {
 				data: { value: 42 },
 			},
 		]
-		const manager = new UserSessionManager([() => createStubSource("test", items)])
+		const manager = new UserSessionManager({
+			providers: [() => createStubSource("test", items)],
+		})
 		const app = buildTestApp(manager, "user-1")
 
 		// Prime the cache
@@ -95,7 +97,9 @@ describe("GET /api/feed", () => {
 				data: { fresh: true },
 			},
 		]
-		const manager = new UserSessionManager([() => createStubSource("test", items)])
+		const manager = new UserSessionManager({
+			providers: [() => createStubSource("test", items)],
+		})
 		const app = buildTestApp(manager, "user-1")
 
 		// No prior refresh — lastFeed() returns null, handler should call refresh()
@@ -125,7 +129,7 @@ describe("GET /api/feed", () => {
 				throw new Error("connection timeout")
 			},
 		}
-		const manager = new UserSessionManager([() => failingSource])
+		const manager = new UserSessionManager({ providers: [() => failingSource] })
 		const app = buildTestApp(manager, "user-1")
 
 		const res = await app.request("/api/feed")

apps/aris-backend/src/feed/http.ts

@@ -5,7 +5,11 @@ import { createMiddleware } from "hono/factory"
 import type { AuthSessionMiddleware } from "../auth/session-middleware.ts"
 import type { UserSessionManager } from "../session/index.ts"
 
-type Env = { Variables: { sessionManager: UserSessionManager } }
+type Env = {
+	Variables: {
+		sessionManager: UserSessionManager
+	}
+}
 
 interface FeedHttpHandlersDeps {
 	sessionManager: UserSessionManager
@@ -29,7 +33,7 @@ async function handleGetFeed(c: Context<Env>) {
 	const sessionManager = c.get("sessionManager")
 	const session = sessionManager.getOrCreate(user.id)
 
-	const feed = session.engine.lastFeed() ?? (await session.engine.refresh())
+	const feed = await session.feed()
 
 	return c.json({
 		items: feed.items,

apps/aris-backend/src/server.ts

@@ -3,30 +3,51 @@ import { Hono } from "hono"
 
 import { registerAuthHandlers } from "./auth/http.ts"
 import { requireSession } from "./auth/session-middleware.ts"
+import { createFeedEnhancer } from "./enhancement/enhance-feed.ts"
+import { createLlmClient } from "./enhancement/llm-client.ts"
 import { registerFeedHttpHandlers } from "./feed/http.ts"
 import { registerLocationHttpHandlers } from "./location/http.ts"
 import { UserSessionManager } from "./session/index.ts"
 import { WeatherSourceProvider } from "./weather/provider.ts"
 
 function main() {
-	const sessionManager = new UserSessionManager([
+	const openrouterApiKey = process.env.OPENROUTER_API_KEY
-		() => new LocationSource(),
+	const feedEnhancer = openrouterApiKey
-		new WeatherSourceProvider({
+		? createFeedEnhancer({
-			credentials: {
+				client: createLlmClient({
-				privateKey: process.env.WEATHERKIT_PRIVATE_KEY!,
+					apiKey: openrouterApiKey,
-				keyId: process.env.WEATHERKIT_KEY_ID!,
+					model: process.env.OPENROUTER_MODEL || undefined,
-				teamId: process.env.WEATHERKIT_TEAM_ID!,
+				}),
-				serviceId: process.env.WEATHERKIT_SERVICE_ID!,
+			})
-			},
+		: null
-		}),
+	if (!feedEnhancer) {
-	])
+		console.warn("[enhancement] OPENROUTER_API_KEY not set — feed enhancement disabled")
+	}
+
+	const sessionManager = new UserSessionManager({
+		providers: [
+			() => new LocationSource(),
+			new WeatherSourceProvider({
+				credentials: {
+					privateKey: process.env.WEATHERKIT_PRIVATE_KEY!,
+					keyId: process.env.WEATHERKIT_KEY_ID!,
+					teamId: process.env.WEATHERKIT_TEAM_ID!,
+					serviceId: process.env.WEATHERKIT_SERVICE_ID!,
+				},
+			}),
+		],
+		feedEnhancer,
+	})
 
 	const app = new Hono()
 
 	app.get("/health", (c) => c.json({ status: "ok" }))
 
 	registerAuthHandlers(app)
-	registerFeedHttpHandlers(app, { sessionManager, authSessionMiddleware: requireSession })
+	registerFeedHttpHandlers(app, {
+		sessionManager,
+		authSessionMiddleware: requireSession,
+	})
 	registerLocationHttpHandlers(app, { sessionManager })
 
 	return app

apps/aris-backend/src/session/user-session-manager.test.ts

@@ -12,7 +12,7 @@ const mockWeatherClient: WeatherKitClient = {
 
 describe("UserSessionManager", () => {
 	test("getOrCreate creates session on first call", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 
@@ -21,7 +21,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("getOrCreate returns same session for same user", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		const session2 = manager.getOrCreate("user-1")
@@ -30,7 +30,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("getOrCreate returns different sessions for different users", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		const session2 = manager.getOrCreate("user-2")
@@ -39,7 +39,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("each user gets independent source instances", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		const session2 = manager.getOrCreate("user-2")
@@ -51,7 +51,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove destroys session and allows re-creation", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		manager.remove("user-1")
@@ -61,13 +61,13 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove is no-op for unknown user", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		expect(() => manager.remove("unknown")).not.toThrow()
 	})
 
 	test("accepts function providers", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 		const result = await session.engine.refresh()
@@ -77,7 +77,9 @@ describe("UserSessionManager", () => {
 
 	test("accepts object providers", () => {
 		const provider = new WeatherSourceProvider({ client: mockWeatherClient })
-		const manager = new UserSessionManager([() => new LocationSource(), provider])
+		const manager = new UserSessionManager({
+			providers: [() => new LocationSource(), provider],
+		})
 
 		const session = manager.getOrCreate("user-1")
 
@@ -86,7 +88,9 @@ describe("UserSessionManager", () => {
 
 	test("accepts mixed providers", () => {
 		const provider = new WeatherSourceProvider({ client: mockWeatherClient })
-		const manager = new UserSessionManager([() => new LocationSource(), provider])
+		const manager = new UserSessionManager({
+			providers: [() => new LocationSource(), provider],
+		})
 
 		const session = manager.getOrCreate("user-1")
 
@@ -95,7 +99,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("refresh returns feed result through session", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 		const result = await session.engine.refresh()
@@ -107,7 +111,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("location update via executeAction works", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 		await session.engine.executeAction("aris.location", "update-location", {
@@ -122,7 +126,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("subscribe receives updates after location push", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 		const callback = mock()
 
 		const session = manager.getOrCreate("user-1")
@@ -142,7 +146,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove stops reactive updates", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 		const callback = mock()
 
 		const session = manager.getOrCreate("user-1")

apps/aris-backend/src/session/user-session-manager.ts

@@ -1,13 +1,21 @@
+import type { FeedEnhancer } from "../enhancement/enhance-feed.ts"
 import type { FeedSourceProviderInput } from "./feed-source-provider.ts"
 
 import { UserSession } from "./user-session.ts"
 
+export interface UserSessionManagerConfig {
+	providers: FeedSourceProviderInput[]
+	feedEnhancer?: FeedEnhancer | null
+}
+
 export class UserSessionManager {
 	private sessions = new Map<string, UserSession>()
 	private readonly providers: FeedSourceProviderInput[]
+	private readonly feedEnhancer: FeedEnhancer | null
 
-	constructor(providers: FeedSourceProviderInput[]) {
+	constructor(config: UserSessionManagerConfig) {
-		this.providers = providers
+		this.providers = config.providers
+		this.feedEnhancer = config.feedEnhancer ?? null
 	}
 
 	getOrCreate(userId: string): UserSession {
@@ -16,7 +24,7 @@ export class UserSessionManager {
 			const sources = this.providers.map((p) =>
 				typeof p === "function" ? p(userId) : p.feedSourceForUser(userId),
 			)
-			session = new UserSession(sources)
+			session = new UserSession(sources, this.feedEnhancer)
 			this.sessions.set(userId, session)
 		}
 		return session

apps/aris-backend/src/session/user-session.test.ts

@@ -1,11 +1,11 @@
-import type { ActionDefinition, Context, FeedSource } from "@aris/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aris/core"
 
 import { LocationSource } from "@aris/source-location"
 import { describe, expect, test } from "bun:test"
 
 import { UserSession } from "./user-session.ts"
 
-function createStubSource(id: string): FeedSource {
+function createStubSource(id: string, items: FeedItem[] = []): FeedSource {
 	return {
 		id,
 		async listActions(): Promise<Record<string, ActionDefinition>> {
@@ -14,11 +14,11 @@ function createStubSource(id: string): FeedSource {
 		async executeAction(): Promise<unknown> {
 			return undefined
 		},
-		async fetchContext(): Promise<Partial<Context> | null> {
+		async fetchContext(): Promise<readonly ContextEntry[] | null> {
 			return null
 		},
 		async fetchItems() {
-			return []
+			return items
 		},
 	}
 }
@@ -70,3 +70,141 @@ describe("UserSession", () => {
 		expect(location.lastLocation!.lat).toBe(51.5)
 	})
 })
+
+describe("UserSession.feed", () => {
+	test("returns feed items without enhancer", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		const session = new UserSession([createStubSource("test", items)])
+
+		const result = await session.feed()
+
+		expect(result.items).toHaveLength(1)
+		expect(result.items[0]!.id).toBe("item-1")
+	})
+
+	test("returns enhanced items when enhancer is provided", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		const enhancer = async (feedItems: FeedItem[]) =>
+			feedItems.map((item) => ({ ...item, data: { ...item.data, enhanced: true } }))
+
+		const session = new UserSession([createStubSource("test", items)], enhancer)
+
+		const result = await session.feed()
+
+		expect(result.items).toHaveLength(1)
+		expect(result.items[0]!.data.enhanced).toBe(true)
+	})
+
+	test("caches enhanced items on subsequent calls", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		let enhancerCallCount = 0
+		const enhancer = async (feedItems: FeedItem[]) => {
+			enhancerCallCount++
+			return feedItems.map((item) => ({ ...item, data: { ...item.data, enhanced: true } }))
+		}
+
+		const session = new UserSession([createStubSource("test", items)], enhancer)
+
+		const result1 = await session.feed()
+		expect(result1.items[0]!.data.enhanced).toBe(true)
+		expect(enhancerCallCount).toBe(1)
+
+		const result2 = await session.feed()
+		expect(result2.items[0]!.data.enhanced).toBe(true)
+		expect(enhancerCallCount).toBe(1)
+	})
+
+	test("re-enhances after engine refresh with new data", async () => {
+		let currentItems: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { version: 1 },
+			},
+		]
+		const source = createStubSource("test", currentItems)
+		// Make fetchItems dynamic so refresh returns new data
+		source.fetchItems = async () => currentItems
+
+		const enhancedVersions: number[] = []
+		const enhancer = async (feedItems: FeedItem[]) => {
+			const version = feedItems[0]!.data.version as number
+			enhancedVersions.push(version)
+			return feedItems.map((item) => ({
+				...item,
+				data: { ...item.data, enhanced: true },
+			}))
+		}
+
+		const session = new UserSession([source], enhancer)
+
+		// First feed triggers refresh + enhancement
+		const result1 = await session.feed()
+		expect(result1.items[0]!.data.version).toBe(1)
+		expect(result1.items[0]!.data.enhanced).toBe(true)
+
+		// Update source data and trigger engine refresh
+		currentItems = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-02T00:00:00.000Z"),
+				data: { version: 2 },
+			},
+		]
+		await session.engine.refresh()
+
+		// Wait for subscriber-triggered background enhancement
+		await new Promise((resolve) => setTimeout(resolve, 10))
+
+		// feed() should now serve re-enhanced items with version 2
+		const result2 = await session.feed()
+		expect(result2.items[0]!.data.version).toBe(2)
+		expect(result2.items[0]!.data.enhanced).toBe(true)
+		expect(enhancedVersions).toEqual([1, 2])
+	})
+
+	test("falls back to unenhanced items when enhancer throws", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		const enhancer = async () => {
+			throw new Error("enhancement exploded")
+		}
+
+		const session = new UserSession([createStubSource("test", items)], enhancer)
+
+		const result = await session.feed()
+
+		expect(result.items).toHaveLength(1)
+		expect(result.items[0]!.id).toBe("item-1")
+		expect(result.items[0]!.data.value).toBe(42)
+	})
+})

apps/aris-backend/src/session/user-session.ts

@@ -1,24 +1,104 @@
-import { FeedEngine, type FeedSource } from "@aris/core"
+import { FeedEngine, type FeedItem, type FeedResult, type FeedSource } from "@aris/core"
+
+import type { FeedEnhancer } from "../enhancement/enhance-feed.ts"
 
 export class UserSession {
 	readonly engine: FeedEngine
 	private sources = new Map<string, FeedSource>()
+	private readonly enhancer: FeedEnhancer | null
+	private enhancedItems: FeedItem[] | null = null
+	/** The FeedResult that enhancedItems was derived from. */
+	private enhancedSource: FeedResult | null = null
+	private enhancingPromise: Promise<void> | null = null
+	private unsubscribe: (() => void) | null = null
 
-	constructor(sources: FeedSource[]) {
+	constructor(sources: FeedSource[], enhancer?: FeedEnhancer | null) {
 		this.engine = new FeedEngine()
+		this.enhancer = enhancer ?? null
 		for (const source of sources) {
 			this.sources.set(source.id, source)
 			this.engine.register(source)
 		}
+
+		if (this.enhancer) {
+			this.unsubscribe = this.engine.subscribe((result) => {
+				this.invalidateEnhancement()
+				this.runEnhancement(result)
+			})
+		}
+
 		this.engine.start()
 	}
 
+	/**
+	 * Returns the current feed, refreshing if the engine cache expired.
+	 * Enhancement runs eagerly on engine updates; this method awaits
+	 * any in-flight enhancement or triggers one if needed.
+	 */
+	async feed(): Promise<FeedResult> {
+		const cached = this.engine.lastFeed()
+		const result = cached ?? (await this.engine.refresh())
+
+		if (!this.enhancer) {
+			return result
+		}
+
+		// Wait for any in-flight background enhancement to finish
+		if (this.enhancingPromise) {
+			await this.enhancingPromise
+		}
+
+		// Serve cached enhancement only if it matches the current engine result
+		if (this.enhancedItems && this.enhancedSource === result) {
+			return { ...result, items: this.enhancedItems }
+		}
+
+		// Stale or missing — re-enhance
+		await this.runEnhancement(result)
+
+		if (this.enhancedItems) {
+			return { ...result, items: this.enhancedItems }
+		}
+
+		return result
+	}
+
 	getSource<T extends FeedSource>(sourceId: string): T | undefined {
 		return this.sources.get(sourceId) as T | undefined
 	}
 
 	destroy(): void {
+		this.unsubscribe?.()
+		this.unsubscribe = null
 		this.engine.stop()
 		this.sources.clear()
+		this.invalidateEnhancement()
+		this.enhancingPromise = null
+	}
+
+	private invalidateEnhancement(): void {
+		this.enhancedItems = null
+		this.enhancedSource = null
+	}
+
+	private runEnhancement(result: FeedResult): Promise<void> {
+		const promise = this.enhance(result)
+		this.enhancingPromise = promise
+		promise.finally(() => {
+			if (this.enhancingPromise === promise) {
+				this.enhancingPromise = null
+			}
+		})
+		return promise
+	}
+
+	private async enhance(result: FeedResult): Promise<void> {
+		try {
+			this.enhancedItems = await this.enhancer!(result.items)
+			this.enhancedSource = result
+		} catch (err) {
+			console.error("[enhancement] Unexpected error:", err)
+			this.invalidateEnhancement()
+		}
 	}
 }

bun.lock

@@ -18,9 +18,12 @@
       "version": "0.0.0",
       "dependencies": {
         "@aris/core": "workspace:*",
+        "@aris/source-caldav": "workspace:*",
+        "@aris/source-google-calendar": "workspace:*",
         "@aris/source-location": "workspace:*",
         "@aris/source-tfl": "workspace:*",
         "@aris/source-weatherkit": "workspace:*",
+        "@openrouter/sdk": "^0.9.11",
         "arktype": "^2.1.29",
         "better-auth": "^1",
         "hono": "^4",
@@ -89,6 +92,17 @@
         "arktype": "^2.1.0",
       },
     },
+    "packages/aris-feed-enhancers": {
+      "name": "@aris/feed-enhancers",
+      "version": "0.0.0",
+      "dependencies": {
+        "@aris/core": "workspace:*",
+        "@aris/source-caldav": "workspace:*",
+        "@aris/source-google-calendar": "workspace:*",
+        "@aris/source-tfl": "workspace:*",
+        "@aris/source-weatherkit": "workspace:*",
+      },
+    },
     "packages/aris-source-caldav": {
       "name": "@aris/source-caldav",
       "version": "0.0.0",
@@ -144,6 +158,8 @@
 
     "@aris/data-source-weatherkit": ["@aris/data-source-weatherkit@workspace:packages/aris-data-source-weatherkit"],
 
+    "@aris/feed-enhancers": ["@aris/feed-enhancers@workspace:packages/aris-feed-enhancers"],
+
     "@aris/source-caldav": ["@aris/source-caldav@workspace:packages/aris-source-caldav"],
 
     "@aris/source-google-calendar": ["@aris/source-google-calendar@workspace:packages/aris-source-google-calendar"],
@@ -530,6 +546,8 @@
 
     "@oclif/screen": ["@oclif/screen@3.0.8", "", {}, "sha512-yx6KAqlt3TAHBduS2fMQtJDL2ufIHnDRArrJEOoTTuizxqmjLT+psGYOHpmMl3gvQpFJ11Hs76guUUktzAF9Bg=="],
 
+    "@openrouter/sdk": ["@openrouter/sdk@0.9.11", "", { "dependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-BgFu6NcIJO4a9aVjr04y3kZ8pyM71j15I+bzfVAGEvxnj+KQNIkBYQGgwrG3D+aT1QpDKLki8btcQmpaxUas6A=="],
+
     "@oxfmt/darwin-arm64": ["@oxfmt/darwin-arm64@0.24.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-aYXuGf/yq8nsyEcHindGhiz9I+GEqLkVq8CfPbd+6VE259CpPEH+CaGHEO1j6vIOmNr8KHRq+IAjeRO2uJpb8A=="],
 
     "@oxfmt/darwin-x64": ["@oxfmt/darwin-x64@0.24.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-vs3b8Bs53hbiNvcNeBilzE/+IhDTWKjSBB3v/ztr664nZk65j0xr+5IHMBNz3CFppmX7o/aBta2PxY+t+4KoPg=="],

packages/aris-core/src/context-bridge.ts

@@ -1,8 +1,10 @@
-import type { Context } from "./context"
+import type { ContextEntry } from "./context"
 import type { ContextProvider } from "./context-provider"
 
+import { contextKey } from "./context"
+
 interface ContextUpdatable {
-	pushContextUpdate(update: Partial<Context>): void
+	pushContextUpdate(entries: readonly ContextEntry[]): void
 }
 
 export interface ProviderError {
@@ -54,7 +56,7 @@ export class ContextBridge {
 		this.providers.set(provider.key, provider as ContextProvider)
 
 		const cleanup = provider.onUpdate((value) => {
-			this.controller.pushContextUpdate({ [provider.key]: value })
+			this.controller.pushContextUpdate([[contextKey(provider.key), value]])
 		})
 		this.cleanups.push(cleanup)
 
@@ -67,7 +69,7 @@ export class ContextBridge {
 	 * Returns errors from providers that failed to fetch.
 	 */
 	async refresh(): Promise<RefreshResult> {
-		const updates: Partial<Context> = {}
+		const collected: ContextEntry[] = []
 		const errors: ProviderError[] = []
 
 		const entries = Array.from(this.providers.entries())
@@ -78,7 +80,7 @@ export class ContextBridge {
 		entries.forEach(([key], i) => {
 			const result = results[i]
 			if (result?.status === "fulfilled") {
-				updates[key] = result.value
+				collected.push([contextKey(key), result.value])
 			} else if (result?.status === "rejected") {
 				errors.push({
 					key,
@@ -87,7 +89,7 @@ export class ContextBridge {
 			}
 		})
 
-		this.controller.pushContextUpdate(updates)
+		this.controller.pushContextUpdate(collected)
 
 		return { errors }
 	}

packages/aris-core/src/context.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, test } from "bun:test"
+
+import type { ContextKey } from "./context"
+
+import { Context, contextKey } from "./context"
+
+interface Weather {
+	temperature: number
+}
+
+interface NextEvent {
+	title: string
+}
+
+const WeatherKey: ContextKey<Weather> = contextKey("aris.weather", "current")
+const NextEventKey: ContextKey<NextEvent> = contextKey("aris.google-calendar", "nextEvent")
+
+describe("Context", () => {
+	describe("get", () => {
+		test("returns undefined for missing key", () => {
+			const ctx = new Context()
+			expect(ctx.get(WeatherKey)).toBeUndefined()
+		})
+
+		test("returns value for exact key match", () => {
+			const ctx = new Context()
+			const weather: Weather = { temperature: 20 }
+			ctx.set([[WeatherKey, weather]])
+
+			expect(ctx.get(WeatherKey)).toEqual(weather)
+		})
+
+		test("distinguishes keys with different parts", () => {
+			const ctx = new Context()
+			ctx.set([
+				[WeatherKey, { temperature: 20 }],
+				[NextEventKey, { title: "Standup" }],
+			])
+
+			expect(ctx.get(WeatherKey)).toEqual({ temperature: 20 })
+			expect(ctx.get(NextEventKey)).toEqual({ title: "Standup" })
+		})
+
+		test("last write wins for same key", () => {
+			const ctx = new Context()
+			ctx.set([[WeatherKey, { temperature: 20 }]])
+			ctx.set([[WeatherKey, { temperature: 25 }]])
+
+			expect(ctx.get(WeatherKey)).toEqual({ temperature: 25 })
+		})
+	})
+
+	describe("find", () => {
+		test("returns empty array when no keys match", () => {
+			const ctx = new Context()
+			expect(ctx.find(WeatherKey)).toEqual([])
+		})
+
+		test("returns exact match as single result", () => {
+			const ctx = new Context()
+			ctx.set([[NextEventKey, { title: "Standup" }]])
+
+			const results = ctx.find(NextEventKey)
+			expect(results).toHaveLength(1)
+			expect(results[0]!.value).toEqual({ title: "Standup" })
+		})
+
+		test("prefix match returns multiple instances", () => {
+			const workKey = contextKey<NextEvent>("aris.google-calendar", "nextEvent", {
+				account: "work",
+			})
+			const personalKey = contextKey<NextEvent>("aris.google-calendar", "nextEvent", {
+				account: "personal",
+			})
+
+			const ctx = new Context()
+			ctx.set([
+				[workKey, { title: "Sprint Planning" }],
+				[personalKey, { title: "Dentist" }],
+			])
+
+			const prefix = contextKey<NextEvent>("aris.google-calendar", "nextEvent")
+			const results = ctx.find(prefix)
+
+			expect(results).toHaveLength(2)
+			const titles = results.map((r) => r.value.title).sort()
+			expect(titles).toEqual(["Dentist", "Sprint Planning"])
+		})
+
+		test("prefix match includes exact match and longer keys", () => {
+			const baseKey = contextKey<NextEvent>("aris.google-calendar", "nextEvent")
+			const instanceKey = contextKey<NextEvent>("aris.google-calendar", "nextEvent", {
+				account: "work",
+			})
+
+			const ctx = new Context()
+			ctx.set([
+				[baseKey, { title: "Base" }],
+				[instanceKey, { title: "Instance" }],
+			])
+
+			const results = ctx.find(baseKey)
+			expect(results).toHaveLength(2)
+		})
+
+		test("does not match keys that share a string prefix but differ at segment boundary", () => {
+			const keyA = contextKey<string>("aris.calendar", "next")
+			const keyB = contextKey<string>("aris.calendar", "nextEvent")
+
+			const ctx = new Context()
+			ctx.set([
+				[keyA, "a"],
+				[keyB, "b"],
+			])
+
+			const results = ctx.find(keyA)
+			expect(results).toHaveLength(1)
+			expect(results[0]!.value).toBe("a")
+		})
+
+		test("object key parts with different property order match", () => {
+			const key1 = contextKey<string>("source", "ctx", { b: 2, a: 1 })
+			const key2 = contextKey<string>("source", "ctx", { a: 1, b: 2 })
+
+			const ctx = new Context()
+			ctx.set([[key1, "value"]])
+
+			// Exact match via get should work regardless of property order
+			expect(ctx.get(key2)).toBe("value")
+
+			// find with the reordered key as prefix should also match
+			const prefix = contextKey<string>("source", "ctx")
+			const results = ctx.find(prefix)
+			expect(results).toHaveLength(1)
+		})
+
+		test("single-segment prefix matches all keys starting with that segment", () => {
+			const ctx = new Context()
+			ctx.set([
+				[contextKey("aris.weather", "current"), { temperature: 20 }],
+				[contextKey("aris.weather", "forecast"), { high: 25 }],
+				[contextKey("aris.calendar", "nextEvent"), { title: "Meeting" }],
+			])
+
+			const results = ctx.find(contextKey("aris.weather"))
+			expect(results).toHaveLength(2)
+		})
+
+		test("does not match shorter keys", () => {
+			const ctx = new Context()
+			ctx.set([[contextKey("aris.weather"), "short"]])
+
+			const results = ctx.find(contextKey("aris.weather", "current"))
+			expect(results).toHaveLength(0)
+		})
+
+		test("numeric key parts match correctly", () => {
+			const ctx = new Context()
+			ctx.set([
+				[contextKey("source", 1, "data"), "one"],
+				[contextKey("source", 2, "data"), "two"],
+			])
+
+			const results = ctx.find(contextKey("source", 1))
+			expect(results).toHaveLength(1)
+			expect(results[0]!.value).toBe("one")
+		})
+	})
+
+	describe("size", () => {
+		test("returns 0 for empty context", () => {
+			expect(new Context().size).toBe(0)
+		})
+
+		test("reflects number of entries", () => {
+			const ctx = new Context()
+			ctx.set([
+				[WeatherKey, { temperature: 20 }],
+				[NextEventKey, { title: "Standup" }],
+			])
+			expect(ctx.size).toBe(2)
+		})
+	})
+})

packages/aris-core/src/context.ts

@@ -1,46 +1,128 @@
 /**
- * Branded type for type-safe context keys.
+ * Tuple-keyed context system inspired by React Query's query keys.
  *
- * Each package defines its own keys with associated value types:
+ * Context keys are arrays that form a hierarchy. Sources write to specific
- * ```ts
+ * keys (e.g., ["aris.google-calendar", "nextEvent", { account: "work" }])
- * const LocationKey: ContextKey<Location> = contextKey("location")
+ * and consumers can query by exact match or prefix match to get all values
- * ```
+ * of a given type across source instances.
  */
-export type ContextKey<T> = string & { __contextValue?: T }
 
-/**
+// -- Key types --
- * Creates a typed context key.
+
- *
+/** A single segment of a context key: string, number, or a record of primitives. */
- * @example
+export type ContextKeyPart = string | number | Record<string, unknown>
- * ```ts
+
- * interface Location { lat: number; lng: number; accuracy: number }
+/** A context key is a readonly tuple of parts, branded with the value type. */
- * const LocationKey: ContextKey<Location> = contextKey("location")
+export type ContextKey<T> = readonly ContextKeyPart[] & { __contextValue?: T }
- * ```
+
- */
+/** Creates a typed context key. */
-export function contextKey<T>(key: string): ContextKey<T> {
+export function contextKey<T>(...parts: ContextKeyPart[]): ContextKey<T> {
-	return key as ContextKey<T>
+	return parts as ContextKey<T>
 }
 
-/**
+// -- Serialization --
- * Type-safe accessor for context values.
- *
- * @example
- * ```ts
- * const location = contextValue(context, LocationKey)
- * if (location) {
- *   console.log(location.lat, location.lng)
- * }
- * ```
- */
-export function contextValue<T>(context: Context, key: ContextKey<T>): T | undefined {
-	return context[key] as T | undefined
-}
 
 /**
- * Arbitrary key-value bag representing the current state.
+ * Deterministic serialization of a context key for use as a Map key.
- * Always includes `time`. Other keys are added by context providers.
+ * Object parts have their keys sorted for stable comparison.
  */
-export interface Context {
+export function serializeKey(key: readonly ContextKeyPart[]): string {
+	return JSON.stringify(key, (_key, value) => {
+		if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+			const sorted: Record<string, unknown> = {}
+			for (const k of Object.keys(value).sort()) {
+				sorted[k] = value[k]
+			}
+			return sorted
+		}
+		return value
+	})
+}
+
+// -- Key matching --
+
+/** Returns true if `key` starts with all parts of `prefix`. */
+function keyStartsWith(key: readonly ContextKeyPart[], prefix: readonly ContextKeyPart[]): boolean {
+	if (key.length < prefix.length) return false
+
+	for (let i = 0; i < prefix.length; i++) {
+		if (!partsEqual(key[i]!, prefix[i]!)) return false
+	}
+
+	return true
+}
+
+/** Recursive structural equality, matching React Query's partialMatchKey approach. */
+function partsEqual(a: unknown, b: unknown): boolean {
+	if (a === b) return true
+	if (typeof a !== typeof b) return false
+	if (a && b && typeof a === "object" && typeof b === "object") {
+		const aKeys = Object.keys(a)
+		const bKeys = Object.keys(b)
+		if (aKeys.length !== bKeys.length) return false
+		return aKeys.every((key) =>
+			partsEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]),
+		)
+	}
+	return false
+}
+
+// -- Context store --
+
+/** A single context entry: a key-value pair. */
+export type ContextEntry<T = unknown> = readonly [ContextKey<T>, T]
+
+/**
+ * Mutable context store with tuple keys.
+ *
+ * Supports exact-match lookups and prefix-match queries.
+ * Sources write context in topological order during refresh.
+ */
+export class Context {
 	time: Date
-	[key: string]: unknown
+	private readonly store: Map<string, { key: readonly ContextKeyPart[]; value: unknown }>
+
+	constructor(time: Date = new Date()) {
+		this.time = time
+		this.store = new Map()
+	}
+
+	/** Merges entries into this context. */
+	set(entries: readonly ContextEntry[]): void {
+		for (const [key, value] of entries) {
+			this.store.set(serializeKey(key), { key, value })
+		}
+	}
+
+	/** Exact-match lookup. Returns the value for the given key, or undefined. */
+	get<T>(key: ContextKey<T>): T | undefined {
+		const entry = this.store.get(serializeKey(key))
+		return entry?.value as T | undefined
+	}
+
+	/**
+	 * Prefix-match query. Returns all entries whose key starts with the given prefix.
+	 *
+	 * @example
+	 * ```ts
+	 * // Get all "nextEvent" values across calendar source instances
+	 * const events = context.find(contextKey("nextEvent"))
+	 * ```
+	 */
+	find<T>(prefix: ContextKey<T>): Array<{ key: readonly ContextKeyPart[]; value: T }> {
+		const results: Array<{ key: readonly ContextKeyPart[]; value: T }> = []
+
+		for (const entry of this.store.values()) {
+			if (keyStartsWith(entry.key, prefix)) {
+				results.push({ key: entry.key, value: entry.value as T })
+			}
+		}
+
+		return results
+	}
+
+	/** Returns the number of entries (excluding time). */
+	get size(): number {
+		return this.store.size
+	}
 }

packages/aris-core/src/data-source.ts

@@ -12,7 +12,7 @@ import type { FeedItem } from "./feed"
  *   readonly type = "weather"
  *
  *   async query(context: Context): Promise<WeatherItem[]> {
- *     const location = contextValue(context, LocationKey)
+ *     const location = context.get(LocationKey)
  *     if (!location) return []
  *     const data = await fetchWeather(location)
  *     return [{

packages/aris-core/src/feed-controller.ts

@@ -1,8 +1,9 @@
-import type { Context } from "./context"
+import type { ContextEntry } from "./context"
 import type { DataSource } from "./data-source"
 import type { FeedItem } from "./feed"
 import type { ReconcileResult } from "./reconciler"
 
+import { Context } from "./context"
 import { Reconciler } from "./reconciler"
 
 export interface FeedControllerConfig {
@@ -40,7 +41,7 @@ const DEFAULT_DEBOUNCE_MS = 100
  * })
  *
  * // Context update triggers debounced reconcile
- * controller.pushContextUpdate({ [LocationKey]: location })
+ * controller.pushContextUpdate([[LocationKey, location]])
  *
  * // Direct reconcile (no debounce)
  * const result = await controller.reconcile()
@@ -59,7 +60,7 @@ export class FeedController<TItems extends FeedItem = never> {
 	private stopped = false
 
 	constructor(config?: FeedControllerConfig) {
-		this.context = config?.initialContext ?? { time: new Date() }
+		this.context = config?.initialContext ?? new Context()
 		this.debounceMs = config?.debounceMs ?? DEFAULT_DEBOUNCE_MS
 		this.timeout = config?.timeout
 	}
@@ -94,9 +95,10 @@ export class FeedController<TItems extends FeedItem = never> {
 		}
 	}
 
-	/** Merges update into context and schedules a debounced reconcile. */
+	/** Merges entries into context and schedules a debounced reconcile. */
-	pushContextUpdate(update: Partial<Context>): void {
+	pushContextUpdate(entries: readonly ContextEntry[]): void {
-		this.context = { ...this.context, ...update, time: new Date() }
+		this.context.time = new Date()
+		this.context.set(entries)
 		this.scheduleReconcile()
 	}
 

packages/aris-core/src/feed-engine.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, test } from "bun:test"
 
-import type { ActionDefinition, Context, ContextKey, FeedItem, FeedSource } from "./index"
+import type { ActionDefinition, ContextEntry, ContextKey, FeedItem, FeedSource } from "./index"
 
 import { FeedEngine } from "./feed-engine"
-import { TimeRelevance, UnknownActionError, contextKey, contextValue } from "./index"
+import { Context, TimeRelevance, UnknownActionError, contextKey } from "./index"
 
 // No-op action methods for test sources
 const noActions = {
@@ -48,7 +48,7 @@ interface SimulatedLocationSource extends FeedSource {
 }
 
 function createLocationSource(): SimulatedLocationSource {
-	let callback: ((update: Partial<Context>) => void) | null = null
+	let callback: ((entries: readonly ContextEntry[]) => void) | null = null
 	let currentLocation: Location = { lat: 0, lng: 0 }
 
 	return {
@@ -63,12 +63,12 @@ function createLocationSource(): SimulatedLocationSource {
 		},
 
 		async fetchContext() {
-			return { [LocationKey]: currentLocation }
+			return [[LocationKey, currentLocation]]
 		},
 
 		simulateUpdate(location: Location) {
 			currentLocation = location
-			callback?.({ [LocationKey]: location })
+			callback?.([[LocationKey, location]])
 		},
 	}
 }
@@ -85,15 +85,15 @@ function createWeatherSource(
 		...noActions,
 
 		async fetchContext(context) {
-			const location = contextValue(context, LocationKey)
+			const location = context.get(LocationKey)
 			if (!location) return null
 
 			const weather = await fetchWeather(location)
-			return { [WeatherKey]: weather }
+			return [[WeatherKey, weather]]
 		},
 
 		async fetchItems(context) {
-			const weather = contextValue(context, WeatherKey)
+			const weather = context.get(WeatherKey)
 			if (!weather) return []
 
 			return [
@@ -123,7 +123,7 @@ function createAlertSource(): FeedSource<AlertFeedItem> {
 		},
 
 		async fetchItems(context) {
-			const weather = contextValue(context, WeatherKey)
+			const weather = context.get(WeatherKey)
 			if (!weather) return []
 
 			if (weather.condition === "storm") {
@@ -265,7 +265,7 @@ describe("FeedEngine", () => {
 				...noActions,
 				async fetchContext() {
 					order.push("location")
-					return { [LocationKey]: { lat: 51.5, lng: -0.1 } }
+					return [[LocationKey, { lat: 51.5, lng: -0.1 }]]
 				},
 			}
 
@@ -275,9 +275,9 @@ describe("FeedEngine", () => {
 				...noActions,
 				async fetchContext(ctx) {
 					order.push("weather")
-					const loc = contextValue(ctx, LocationKey)
+					const loc = ctx.get(LocationKey)
 					expect(loc).toBeDefined()
-					return { [WeatherKey]: { temperature: 20, condition: "sunny" } }
+					return [[WeatherKey, { temperature: 20, condition: "sunny" }]]
 				},
 			}
 
@@ -298,11 +298,11 @@ describe("FeedEngine", () => {
 
 			const { context } = await engine.refresh()
 
-			expect(contextValue(context, LocationKey)).toEqual({
+			expect(context.get(LocationKey)).toEqual({
 				lat: 51.5,
 				lng: -0.1,
 			})
-			expect(contextValue(context, WeatherKey)).toEqual({
+			expect(context.get(WeatherKey)).toEqual({
 				temperature: 20,
 				condition: "sunny",
 			})
@@ -361,7 +361,7 @@ describe("FeedEngine", () => {
 
 			const { context, items } = await engine.refresh()
 
-			expect(contextValue(context, WeatherKey)).toBeUndefined()
+			expect(context.get(WeatherKey)).toBeUndefined()
 			expect(items).toHaveLength(0)
 		})
 
@@ -459,7 +459,7 @@ describe("FeedEngine", () => {
 			await engine.refresh()
 
 			const context = engine.currentContext()
-			expect(contextValue(context, LocationKey)).toEqual({
+			expect(context.get(LocationKey)).toEqual({
 				lat: 51.5,
 				lng: -0.1,
 			})
@@ -734,7 +734,7 @@ describe("FeedEngine", () => {
 		})
 
 		test("reactive item update refreshes cache", async () => {
-			let itemUpdateCallback: (() => void) | null = null
+			let itemUpdateCallback: ((items: FeedItem[]) => void) | null = null
 
 			const source: FeedSource = {
 				id: "reactive-items",
@@ -765,7 +765,7 @@ describe("FeedEngine", () => {
 			engine.start()
 
 			// Trigger item update
-			itemUpdateCallback!()
+			itemUpdateCallback!([])
 
 			// Wait for async refresh
 			await new Promise((resolve) => setTimeout(resolve, 50))
@@ -885,12 +885,12 @@ describe("FeedEngine", () => {
 				...noActions,
 				async fetchContext(ctx) {
 					fetchCount++
-					const loc = contextValue(ctx, LocationKey)
+					const loc = ctx.get(LocationKey)
 					if (!loc) return null
-					return { [WeatherKey]: { temperature: 20, condition: "sunny" } }
+					return [[WeatherKey, { temperature: 20, condition: "sunny" }]]
 				},
 				async fetchItems(ctx) {
-					const weather = contextValue(ctx, WeatherKey)
+					const weather = ctx.get(WeatherKey)
 					if (!weather) return []
 					return [
 						{

packages/aris-core/src/feed-engine.ts

@@ -1,9 +1,11 @@
 import type { ActionDefinition } from "./action"
-import type { Context } from "./context"
+import type { ContextEntry } from "./context"
 import type { FeedItem } from "./feed"
 import type { FeedPostProcessor, ItemGroup } from "./feed-post-processor"
 import type { FeedSource } from "./feed-source"
 
+import { Context } from "./context"
+
 export interface SourceError {
 	sourceId: string
 	error: Error
@@ -65,7 +67,7 @@ interface SourceGraph {
 export class FeedEngine<TItems extends FeedItem = FeedItem> {
 	private sources = new Map<string, FeedSource>()
 	private graph: SourceGraph | null = null
-	private context: Context = { time: new Date() }
+	private context: Context = new Context()
 	private subscribers = new Set<FeedSubscriber<TItems>>()
 	private cleanups: Array<() => void> = []
 	private started = false
@@ -138,14 +140,14 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 		const errors: SourceError[] = []
 
 		// Reset context with fresh time
-		let context: Context = { time: new Date() }
+		const context = new Context()
 
 		// Run fetchContext in topological order
 		for (const source of graph.sorted) {
 			try {
-				const update = await source.fetchContext(context)
+				const entries = await source.fetchContext(context)
-				if (update) {
+				if (entries) {
-					context = { ...context, ...update }
+					context.set(entries)
 				}
 			} catch (err) {
 				errors.push({
@@ -213,8 +215,8 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 		for (const source of graph.sorted) {
 			if (source.onContextUpdate) {
 				const cleanup = source.onContextUpdate(
-					(update) => {
+					(entries) => {
-						this.handleContextUpdate(source.id, update)
+						this.handleContextUpdate(source.id, entries)
 					},
 					() => this.context,
 				)
@@ -365,8 +367,9 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 		return this.graph
 	}
 
-	private handleContextUpdate(sourceId: string, update: Partial<Context>): void {
+	private handleContextUpdate(sourceId: string, entries: readonly ContextEntry[]): void {
-		this.context = { ...this.context, ...update, time: new Date() }
+		this.context.time = new Date()
+		this.context.set(entries)
 
 		// Re-run dependents and notify
 		this.refreshDependents(sourceId)
@@ -381,9 +384,9 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 			const source = graph.sources.get(id)
 			if (source) {
 				try {
-					const update = await source.fetchContext(this.context)
+					const entries = await source.fetchContext(this.context)
-					if (update) {
+					if (entries) {
-						this.context = { ...this.context, ...update }
+						this.context.set(entries)
 					}
 				} catch {
 					// Errors during reactive updates are logged but don't stop propagation

packages/aris-core/src/feed-post-processor.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, mock, test } from "bun:test"
 
-import type { ActionDefinition, FeedItem, FeedPostProcessor, FeedSource } from "./index"
+import type {
+	ActionDefinition,
+	ContextEntry,
+	FeedItem,
+	FeedPostProcessor,
+	FeedSource,
+} from "./index"
 
 import { FeedEngine } from "./feed-engine"
 import { UnknownActionError } from "./index"
@@ -471,7 +477,7 @@ describe("FeedPostProcessor", () => {
 		test("post-processors run during reactive context updates", async () => {
 			let callCount = 0
 
-			let triggerUpdate: ((update: Record<string, unknown>) => void) | null = null
+			let triggerUpdate: ((entries: readonly ContextEntry[]) => void) | null = null
 
 			const source: FeedSource = {
 				id: "aris.reactive",
@@ -502,7 +508,7 @@ describe("FeedPostProcessor", () => {
 			const countAfterStart = callCount
 
 			// Trigger a reactive context update
-			triggerUpdate!({ foo: "bar" })
+			triggerUpdate!([])
 			await new Promise((resolve) => setTimeout(resolve, 50))
 
 			expect(callCount).toBeGreaterThan(countAfterStart)
@@ -513,7 +519,7 @@ describe("FeedPostProcessor", () => {
 		test("post-processors run during reactive item updates", async () => {
 			let callCount = 0
 
-			let triggerItemsUpdate: (() => void) | null = null
+			let triggerItemsUpdate: ((items: FeedItem[]) => void) | null = null
 
 			const source: FeedSource = {
 				id: "aris.reactive",
@@ -543,7 +549,7 @@ describe("FeedPostProcessor", () => {
 			const countAfterStart = callCount
 
 			// Trigger a reactive items update
-			triggerItemsUpdate!()
+			triggerItemsUpdate!([weatherItem("w1", 25)])
 			await new Promise((resolve) => setTimeout(resolve, 50))
 
 			expect(callCount).toBeGreaterThan(countAfterStart)

packages/aris-core/src/feed-source.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test } from "bun:test"
 
-import type { ActionDefinition, Context, ContextKey, FeedItem, FeedSource } from "./index"
+import type { ActionDefinition, ContextEntry, ContextKey, FeedItem, FeedSource } from "./index"
 
-import { TimeRelevance, UnknownActionError, contextKey, contextValue } from "./index"
+import { Context, TimeRelevance, UnknownActionError, contextKey } from "./index"
 
 // No-op action methods for test sources
 const noActions = {
@@ -47,7 +47,7 @@ interface SimulatedLocationSource extends FeedSource {
 }
 
 function createLocationSource(): SimulatedLocationSource {
-	let callback: ((update: Partial<Context>) => void) | null = null
+	let callback: ((entries: readonly ContextEntry[]) => void) | null = null
 	let currentLocation: Location = { lat: 0, lng: 0 }
 
 	return {
@@ -62,12 +62,12 @@ function createLocationSource(): SimulatedLocationSource {
 		},
 
 		async fetchContext() {
-			return { [LocationKey]: currentLocation }
+			return [[LocationKey, currentLocation]]
 		},
 
 		simulateUpdate(location: Location) {
 			currentLocation = location
-			callback?.({ [LocationKey]: location })
+			callback?.([[LocationKey, location]])
 		},
 	}
 }
@@ -84,15 +84,15 @@ function createWeatherSource(
 		...noActions,
 
 		async fetchContext(context) {
-			const location = contextValue(context, LocationKey)
+			const location = context.get(LocationKey)
 			if (!location) return null
 
 			const weather = await fetchWeather(location)
-			return { [WeatherKey]: weather }
+			return [[WeatherKey, weather]]
 		},
 
 		async fetchItems(context) {
-			const weather = contextValue(context, WeatherKey)
+			const weather = context.get(WeatherKey)
 			if (!weather) return []
 
 			return [
@@ -122,7 +122,7 @@ function createAlertSource(): FeedSource<AlertFeedItem> {
 		},
 
 		async fetchItems(context) {
-			const weather = contextValue(context, WeatherKey)
+			const weather = context.get(WeatherKey)
 			if (!weather) return []
 
 			if (weather.condition === "storm") {
@@ -207,13 +207,13 @@ function buildGraph(sources: FeedSource[]): SourceGraph {
 }
 
 async function refreshGraph(graph: SourceGraph): Promise<{ context: Context; items: FeedItem[] }> {
-	let context: Context = { time: new Date() }
+	const context = new Context()
 
 	// Run fetchContext in topological order
 	for (const source of graph.sorted) {
-		const update = await source.fetchContext(context)
+		const entries = await source.fetchContext(context)
-		if (update) {
+		if (entries) {
-			context = { ...context, ...update }
+			context.set(entries)
 		}
 	}
 
@@ -265,7 +265,7 @@ describe("FeedSource", () => {
 
 		test("source without context returns null from fetchContext", async () => {
 			const source = createAlertSource()
-			const result = await source.fetchContext({ time: new Date() })
+			const result = await source.fetchContext(new Context())
 			expect(result).toBeNull()
 		})
 	})
@@ -369,7 +369,7 @@ describe("FeedSource", () => {
 				...noActions,
 				async fetchContext() {
 					order.push("location")
-					return { [LocationKey]: { lat: 51.5, lng: -0.1 } }
+					return [[LocationKey, { lat: 51.5, lng: -0.1 }]]
 				},
 			}
 
@@ -379,9 +379,9 @@ describe("FeedSource", () => {
 				...noActions,
 				async fetchContext(ctx) {
 					order.push("weather")
-					const loc = contextValue(ctx, LocationKey)
+					const loc = ctx.get(LocationKey)
 					expect(loc).toBeDefined()
-					return { [WeatherKey]: { temperature: 20, condition: "sunny" } }
+					return [[WeatherKey, { temperature: 20, condition: "sunny" }]]
 				},
 			}
 
@@ -400,11 +400,11 @@ describe("FeedSource", () => {
 			const graph = buildGraph([location, weather])
 			const { context } = await refreshGraph(graph)
 
-			expect(contextValue(context, LocationKey)).toEqual({
+			expect(context.get(LocationKey)).toEqual({
 				lat: 51.5,
 				lng: -0.1,
 			})
-			expect(contextValue(context, WeatherKey)).toEqual({
+			expect(context.get(WeatherKey)).toEqual({
 				temperature: 20,
 				condition: "sunny",
 			})
@@ -447,12 +447,10 @@ describe("FeedSource", () => {
 		})
 
 		test("source without location context returns empty items", async () => {
-			// Location source exists but hasn't been updated
 			const location: FeedSource = {
 				id: "location",
 				...noActions,
 				async fetchContext() {
-					// Simulate no location available
 					return null
 				},
 			}
@@ -462,7 +460,7 @@ describe("FeedSource", () => {
 			const graph = buildGraph([location, weather])
 			const { context, items } = await refreshGraph(graph)
 
-			expect(contextValue(context, WeatherKey)).toBeUndefined()
+			expect(context.get(WeatherKey)).toBeUndefined()
 			expect(items).toHaveLength(0)
 		})
 	})
@@ -476,7 +474,7 @@ describe("FeedSource", () => {
 				() => {
 					updateCount++
 				},
-				() => ({ time: new Date() }),
+				() => new Context(),
 			)
 
 			location.simulateUpdate({ lat: 1, lng: 1 })

packages/aris-core/src/feed-source.ts

@@ -1,5 +1,5 @@
 import type { ActionDefinition } from "./action"
-import type { Context } from "./context"
+import type { Context, ContextEntry } from "./context"
 import type { FeedItem } from "./feed"
 
 /**
@@ -57,7 +57,7 @@ export interface FeedSource<TItem extends FeedItem = FeedItem> {
 	 * Maps to: source/contextUpdated (notification, source → host)
 	 */
 	onContextUpdate?(
-		callback: (update: Partial<Context>) => void,
+		callback: (entries: readonly ContextEntry[]) => void,
 		getContext: () => Context,
 	): () => void
 
@@ -67,7 +67,7 @@ export interface FeedSource<TItem extends FeedItem = FeedItem> {
 	 * Return null if this source cannot provide context.
 	 * Maps to: source/fetchContext
 	 */
-	fetchContext(context: Context): Promise<Partial<Context> | null>
+	fetchContext(context: Context): Promise<readonly ContextEntry[] | null>
 
 	/**
 	 * Subscribe to reactive feed item updates.

packages/aris-core/src/feed.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test"
+
+import type { FeedItem, Slot } from "./feed"
+
+describe("FeedItem slots", () => {
+	test("FeedItem without slots is valid", () => {
+		const item: FeedItem<"test", { value: number }> = {
+			id: "test-1",
+			type: "test",
+			timestamp: new Date(),
+			data: { value: 42 },
+		}
+
+		expect(item.slots).toBeUndefined()
+	})
+
+	test("FeedItem with unfilled slots", () => {
+		const item: FeedItem<"weather", { temp: number }> = {
+			id: "weather-1",
+			type: "weather",
+			timestamp: new Date(),
+			data: { temp: 18 },
+			slots: {
+				insight: {
+					description: "A short contextual insight about the current weather",
+					content: null,
+				},
+				"cross-source": {
+					description: "Connection between weather and calendar events",
+					content: null,
+				},
+			},
+		}
+
+		expect(item.slots).toBeDefined()
+		expect(Object.keys(item.slots!)).toEqual(["insight", "cross-source"])
+		expect(item.slots!.insight!.content).toBeNull()
+		expect(item.slots!["cross-source"]!.content).toBeNull()
+	})
+
+	test("FeedItem with filled slots", () => {
+		const item: FeedItem<"weather", { temp: number }> = {
+			id: "weather-1",
+			type: "weather",
+			timestamp: new Date(),
+			data: { temp: 18 },
+			slots: {
+				insight: {
+					description: "A short contextual insight about the current weather",
+					content: "Rain after 3pm — grab a jacket before your walk",
+				},
+			},
+		}
+
+		expect(item.slots!.insight!.content).toBe("Rain after 3pm — grab a jacket before your walk")
+	})
+
+	test("Slot interface enforces required fields", () => {
+		const slot: Slot = {
+			description: "Test slot description",
+			content: null,
+		}
+
+		expect(slot.description).toBe("Test slot description")
+		expect(slot.content).toBeNull()
+
+		const filledSlot: Slot = {
+			description: "Test slot description",
+			content: "Filled content",
+		}
+
+		expect(filledSlot.content).toBe("Filled content")
+	})
+
+	test("FeedItem with empty slots record", () => {
+		const item: FeedItem<"test", { value: number }> = {
+			id: "test-1",
+			type: "test",
+			timestamp: new Date(),
+			data: { value: 1 },
+			slots: {},
+		}
+
+		expect(item.slots).toEqual({})
+		expect(Object.keys(item.slots!)).toHaveLength(0)
+	})
+})

packages/aris-core/src/feed.ts

@@ -23,6 +23,20 @@ export interface FeedItemSignals {
 	timeRelevance?: TimeRelevance
 }
 
+/**
+ * A named slot for LLM-fillable content on a feed item.
+ *
+ * Sources declare slots with a description that tells the LLM what content
+ * to generate. The enhancement harness fills `content` asynchronously;
+ * until then it remains `null`.
+ */
+export interface Slot {
+	/** Tells the LLM what this slot wants — written by the source */
+	description: string
+	/** LLM-filled text content, null until enhanced */
+	content: string | null
+}
+
 /**
  * A single item in the feed.
  *
@@ -36,6 +50,12 @@ export interface FeedItemSignals {
  *   timestamp: new Date(),
  *   data: { temp: 18, condition: "cloudy" },
  *   signals: { urgency: 0.5, timeRelevance: "ambient" },
+ *   slots: {
+ *     insight: {
+ *       description: "A short contextual insight about the current weather",
+ *       content: null,
+ *     },
+ *   },
  * }
  * ```
  */
@@ -53,4 +73,6 @@ export interface FeedItem<
 	data: TData
 	/** Source-provided hints for post-processors. Optional — omit if no signals apply. */
 	signals?: FeedItemSignals
+	/** Named slots for LLM-fillable content. Keys are slot names. */
+	slots?: Record<string, Slot>
 }

packages/aris-core/src/index.ts

@@ -1,13 +1,13 @@
 // Context
-export type { Context, ContextKey } from "./context"
+export type { ContextEntry, ContextKey, ContextKeyPart } from "./context"
-export { contextKey, contextValue } from "./context"
+export { Context, contextKey, serializeKey } from "./context"
 
 // Actions
 export type { ActionDefinition } from "./action"
 export { UnknownActionError } from "./action"
 
 // Feed
-export type { FeedItem, FeedItemSignals } from "./feed"
+export type { FeedItem, FeedItemSignals, Slot } from "./feed"
 export { TimeRelevance } from "./feed"
 
 // Feed Source

packages/aris-data-source-weatherkit/src/data-source.test.ts

@@ -1,5 +1,6 @@
-import type { Context } from "@aris/core"
+import type { ContextKey } from "@aris/core"
 
+import { Context, contextKey } from "@aris/core"
 import { describe, expect, test } from "bun:test"
 
 import type { WeatherKitClient, WeatherKitResponse } from "./weatherkit"
@@ -15,14 +16,25 @@ const mockCredentials = {
 	serviceId: "mock",
 }
 
+interface LocationData {
+	lat: number
+	lng: number
+	accuracy: number
+}
+
+const LocationKey: ContextKey<LocationData> = contextKey("aris.location", "location")
+
 const createMockClient = (response: WeatherKitResponse): WeatherKitClient => ({
 	fetch: async () => response,
 })
 
-const createMockContext = (location?: { lat: number; lng: number }): Context => ({
+function createMockContext(location?: { lat: number; lng: number }): Context {
-	time: new Date("2026-01-17T00:00:00Z"),
+	const ctx = new Context(new Date("2026-01-17T00:00:00Z"))
-	location: location ? { ...location, accuracy: 10 } : undefined,
+	if (location) {
-})
+		ctx.set([[LocationKey, { ...location, accuracy: 10 }]])
+	}
+	return ctx
+}
 
 describe("WeatherKitDataSource", () => {
 	test("returns empty array when location is missing", async () => {

packages/aris-data-source-weatherkit/src/data-source.ts

@@ -1,6 +1,6 @@
-import type { Context, DataSource, FeedItemSignals } from "@aris/core"
+import type { Context, ContextKey, DataSource, FeedItemSignals } from "@aris/core"
 
-import { TimeRelevance } from "@aris/core"
+import { TimeRelevance, contextKey } from "@aris/core"
 
 import {
 	WeatherFeedItemType,
@@ -40,6 +40,13 @@ export interface WeatherKitQueryConfig {
 	units?: Units
 }
 
+interface LocationData {
+	lat: number
+	lng: number
+}
+
+const LocationKey: ContextKey<LocationData> = contextKey("aris.location", "location")
+
 export class WeatherKitDataSource implements DataSource<WeatherFeedItem, WeatherKitQueryConfig> {
 	private readonly DEFAULT_HOURLY_LIMIT = 12
 	private readonly DEFAULT_DAILY_LIMIT = 7
@@ -59,7 +66,8 @@ export class WeatherKitDataSource implements DataSource<WeatherFeedItem, Weather
 	}
 
 	async query(context: Context, config: WeatherKitQueryConfig = {}): Promise<WeatherFeedItem[]> {
-		if (!context.location) {
+		const location = context.get(LocationKey)
+		if (!location) {
 			return []
 		}
 
@@ -67,8 +75,8 @@ export class WeatherKitDataSource implements DataSource<WeatherFeedItem, Weather
 		const timestamp = context.time
 
 		const response = await this.client.fetch({
-			lat: context.location.lat,
+			lat: location.lat,
-			lng: context.location.lng,
+			lng: location.lng,
 		})
 
 		const items: WeatherFeedItem[] = []

packages/aris-feed-enhancers/package.json

@@ -0,0 +1,17 @@
+{
+	"name": "@aris/feed-enhancers",
+	"version": "0.0.0",
+	"type": "module",
+	"main": "src/index.ts",
+	"types": "src/index.ts",
+	"scripts": {
+		"test": "bun test src/"
+	},
+	"dependencies": {
+		"@aris/core": "workspace:*",
+		"@aris/source-caldav": "workspace:*",
+		"@aris/source-google-calendar": "workspace:*",
+		"@aris/source-tfl": "workspace:*",
+		"@aris/source-weatherkit": "workspace:*"
+	}
+}

packages/aris-feed-enhancers/src/index.ts

@@ -0,0 +1 @@
+export { createTimeOfDayEnhancer, type TimeOfDayEnhancerOptions } from "./time-of-day-enhancer.ts"

packages/aris-feed-enhancers/src/time-of-day-enhancer.test.ts

@@ -0,0 +1,704 @@
+import type { FeedItem, FeedItemSignals } from "@aris/core"
+
+import { Context, TimeRelevance } from "@aris/core"
+import { CalDavFeedItemType } from "@aris/source-caldav"
+import { CalendarFeedItemType } from "@aris/source-google-calendar"
+import { TflFeedItemType } from "@aris/source-tfl"
+import { WeatherFeedItemType } from "@aris/source-weatherkit"
+import { describe, expect, test } from "bun:test"
+
+import {
+	createTimeOfDayEnhancer,
+	getTimePeriod,
+	getDayType,
+	TimePeriod,
+	DayType,
+} from "./time-of-day-enhancer"
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function makeContext(date: Date): Context {
+	return new Context(date)
+}
+
+function makeDate(year: number, month: number, day: number, hour: number, minute = 0): Date {
+	return new Date(year, month - 1, day, hour, minute, 0, 0)
+}
+
+/** Tuesday 2025-07-08 at given hour:minute */
+function tuesday(hour: number, minute = 0): Date {
+	return makeDate(2025, 7, 8, hour, minute)
+}
+
+/** Saturday 2025-07-12 at given hour:minute */
+function saturday(hour: number, minute = 0): Date {
+	return makeDate(2025, 7, 12, hour, minute)
+}
+
+function weatherCurrent(id = "w-current"): FeedItem {
+	return {
+		id,
+		type: WeatherFeedItemType.Current,
+		timestamp: new Date(),
+		data: { temperature: 18, precipitationIntensity: 0 },
+	}
+}
+
+function weatherCurrentRainy(id = "w-current-rain"): FeedItem {
+	return {
+		id,
+		type: WeatherFeedItemType.Current,
+		timestamp: new Date(),
+		data: { temperature: 12, precipitationIntensity: 2.5 },
+	}
+}
+
+function weatherCurrentExtreme(id = "w-current-extreme"): FeedItem {
+	return {
+		id,
+		type: WeatherFeedItemType.Current,
+		timestamp: new Date(),
+		data: { temperature: -5, precipitationIntensity: 0 },
+	}
+}
+
+function weatherHourly(id = "w-hourly"): FeedItem {
+	return {
+		id,
+		type: WeatherFeedItemType.Hourly,
+		timestamp: new Date(),
+		data: { forecastTime: new Date(), temperature: 20 },
+	}
+}
+
+function weatherDaily(id = "w-daily"): FeedItem {
+	return {
+		id,
+		type: WeatherFeedItemType.Daily,
+		timestamp: new Date(),
+		data: { forecastDate: new Date() },
+	}
+}
+
+function weatherAlert(id = "w-alert", urgency = 0.9): FeedItem {
+	return {
+		id,
+		type: WeatherFeedItemType.Alert,
+		timestamp: new Date(),
+		data: { severity: "extreme" },
+		signals: { urgency, timeRelevance: TimeRelevance.Imminent },
+	}
+}
+
+function calendarEvent(
+	id: string,
+	startTime: Date,
+	options: { location?: string; signals?: FeedItemSignals } = {},
+): FeedItem {
+	return {
+		id,
+		type: CalendarFeedItemType.Event,
+		timestamp: new Date(),
+		data: {
+			eventId: id,
+			calendarId: "primary",
+			title: `Event ${id}`,
+			description: null,
+			location: options.location ?? null,
+			startTime,
+			endTime: new Date(startTime.getTime() + 3_600_000),
+			isAllDay: false,
+			status: "confirmed",
+			htmlLink: "",
+		},
+		signals: options.signals,
+	}
+}
+
+function calendarAllDay(id: string): FeedItem {
+	return {
+		id,
+		type: CalendarFeedItemType.AllDay,
+		timestamp: new Date(),
+		data: {
+			eventId: id,
+			calendarId: "primary",
+			title: `All Day ${id}`,
+			description: null,
+			location: null,
+			startTime: new Date(),
+			endTime: new Date(),
+			isAllDay: true,
+			status: "confirmed",
+			htmlLink: "",
+		},
+		signals: { timeRelevance: TimeRelevance.Ambient },
+	}
+}
+
+function caldavEvent(
+	id: string,
+	startDate: Date,
+	options: { location?: string; signals?: FeedItemSignals } = {},
+): FeedItem {
+	return {
+		id,
+		type: CalDavFeedItemType.Event,
+		timestamp: new Date(),
+		data: {
+			uid: id,
+			title: `CalDAV ${id}`,
+			startDate,
+			endDate: new Date(startDate.getTime() + 3_600_000),
+			isAllDay: false,
+			location: options.location ?? null,
+			description: null,
+			calendarName: null,
+			status: "confirmed",
+			url: null,
+			organizer: null,
+			attendees: [],
+			alarms: [],
+			recurrenceId: null,
+		},
+		signals: options.signals,
+	}
+}
+
+function tflAlert(id = "tfl-1", urgency = 0.8): FeedItem {
+	return {
+		id,
+		type: TflFeedItemType.Alert,
+		timestamp: new Date(),
+		data: {
+			line: "northern",
+			lineName: "Northern",
+			severity: "major-delays",
+			description: "Delays",
+		},
+		signals: { urgency, timeRelevance: TimeRelevance.Imminent },
+	}
+}
+
+function unknownItem(id = "unknown-1"): FeedItem {
+	return {
+		id,
+		type: "some-future-type",
+		timestamp: new Date(),
+		data: { foo: "bar" },
+	}
+}
+
+// =============================================================================
+// Period detection
+// =============================================================================
+
+describe("getTimePeriod", () => {
+	test("morning: 06:00–11:59", () => {
+		expect(getTimePeriod(tuesday(6))).toBe(TimePeriod.Morning)
+		expect(getTimePeriod(tuesday(8))).toBe(TimePeriod.Morning)
+		expect(getTimePeriod(tuesday(11, 59))).toBe(TimePeriod.Morning)
+	})
+
+	test("afternoon: 12:00–16:59", () => {
+		expect(getTimePeriod(tuesday(12))).toBe(TimePeriod.Afternoon)
+		expect(getTimePeriod(tuesday(14))).toBe(TimePeriod.Afternoon)
+		expect(getTimePeriod(tuesday(16, 59))).toBe(TimePeriod.Afternoon)
+	})
+
+	test("evening: 17:00–21:59", () => {
+		expect(getTimePeriod(tuesday(17))).toBe(TimePeriod.Evening)
+		expect(getTimePeriod(tuesday(19))).toBe(TimePeriod.Evening)
+		expect(getTimePeriod(tuesday(21, 59))).toBe(TimePeriod.Evening)
+	})
+
+	test("night: 22:00–05:59", () => {
+		expect(getTimePeriod(tuesday(22))).toBe(TimePeriod.Night)
+		expect(getTimePeriod(tuesday(0))).toBe(TimePeriod.Night)
+		expect(getTimePeriod(tuesday(3))).toBe(TimePeriod.Night)
+		expect(getTimePeriod(tuesday(5, 59))).toBe(TimePeriod.Night)
+	})
+})
+
+describe("getDayType", () => {
+	test("weekday: Monday–Friday", () => {
+		// 2025-07-07 is Monday, 2025-07-08 is Tuesday, 2025-07-11 is Friday
+		expect(getDayType(makeDate(2025, 7, 7, 10))).toBe(DayType.Weekday)
+		expect(getDayType(tuesday(10))).toBe(DayType.Weekday)
+		expect(getDayType(makeDate(2025, 7, 11, 10))).toBe(DayType.Weekday)
+	})
+
+	test("weekend: Saturday–Sunday", () => {
+		expect(getDayType(saturday(10))).toBe(DayType.Weekend)
+		expect(getDayType(makeDate(2025, 7, 13, 10))).toBe(DayType.Weekend) // Sunday
+	})
+})
+
+// =============================================================================
+// Morning
+// =============================================================================
+
+describe("morning weekday", () => {
+	const now = tuesday(8)
+	const ctx = makeContext(now)
+
+	test("boosts weather-current and weather-alert, demotes weather-hourly", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const items = [weatherCurrent(), weatherHourly(), weatherAlert()]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["w-current"]).toBeGreaterThan(0)
+		expect(result.boost!["w-alert"]).toBeGreaterThan(0)
+		expect(result.boost!["w-hourly"]).toBeLessThan(0)
+	})
+
+	test("boosts first calendar event of the day", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event1 = calendarEvent("c1", tuesday(9))
+		const event2 = calendarEvent("c2", tuesday(14))
+		const result = await enhancer([event1, event2], ctx)
+
+		expect(result.boost!["c1"]).toBeGreaterThan(0)
+		// Second event should not get the first-event boost
+		expect(result.boost?.["c2"] ?? 0).toBeLessThanOrEqual(0)
+	})
+
+	test("boosts TfL alerts", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const result = await enhancer([tflAlert()], ctx)
+
+		expect(result.boost!["tfl-1"]).toBeGreaterThan(0)
+	})
+})
+
+describe("morning weekend", () => {
+	const now = saturday(9)
+	const ctx = makeContext(now)
+
+	test("boosts weather-current and weather-daily", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const items = [weatherCurrent(), weatherDaily()]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["w-current"]).toBeGreaterThan(0)
+		expect(result.boost!["w-daily"]).toBeGreaterThan(0)
+	})
+
+	test("demotes calendar events and TfL alerts", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", saturday(10))
+		const items = [event, tflAlert()]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["c1"]).toBeLessThan(0)
+		expect(result.boost!["tfl-1"]).toBeLessThan(0)
+	})
+})
+
+// =============================================================================
+// Afternoon
+// =============================================================================
+
+describe("afternoon weekday", () => {
+	const now = tuesday(14)
+	const ctx = makeContext(now)
+
+	test("boosts imminent calendar events", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", tuesday(14, 10), {
+			signals: { timeRelevance: TimeRelevance.Imminent },
+		})
+		const result = await enhancer([event], ctx)
+
+		expect(result.boost!["c1"]).toBeGreaterThan(0)
+	})
+
+	test("demotes weather-current and weather-hourly", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const items = [weatherCurrent(), weatherHourly()]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["w-current"]).toBeLessThan(0)
+		expect(result.boost!["w-hourly"]).toBeLessThan(0)
+	})
+})
+
+describe("afternoon weekend", () => {
+	const now = saturday(14)
+	const ctx = makeContext(now)
+
+	test("boosts weather-current, demotes calendar events", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", saturday(15))
+		const items = [weatherCurrent(), event]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["w-current"]).toBeGreaterThan(0)
+		expect(result.boost!["c1"]).toBeLessThan(0)
+	})
+})
+
+// =============================================================================
+// Evening
+// =============================================================================
+
+describe("evening weekday", () => {
+	const now = tuesday(19)
+	const ctx = makeContext(now)
+
+	test("suppresses ambient work calendar events", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", tuesday(9), {
+			signals: { timeRelevance: TimeRelevance.Ambient },
+		})
+		const result = await enhancer([event], ctx)
+
+		expect(result.suppress).toContain("c1")
+	})
+
+	test("demotes TfL alerts", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const result = await enhancer([tflAlert()], ctx)
+
+		expect(result.boost!["tfl-1"]).toBeLessThan(0)
+	})
+
+	test("boosts weather-daily and all-day calendar events", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const items = [weatherDaily(), calendarAllDay("ad1")]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["w-daily"]).toBeGreaterThan(0)
+		expect(result.boost!["ad1"]).toBeGreaterThan(0)
+	})
+})
+
+describe("evening weekend", () => {
+	const now = saturday(19)
+	const ctx = makeContext(now)
+
+	test("boosts weather-current, suppresses ambient calendar events", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", saturday(9), {
+			signals: { timeRelevance: TimeRelevance.Ambient },
+		})
+		const items = [weatherCurrent(), event]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["w-current"]).toBeGreaterThan(0)
+		expect(result.suppress).toContain("c1")
+	})
+
+	test("demotes TfL alerts more aggressively", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const result = await enhancer([tflAlert()], ctx)
+
+		expect(result.boost!["tfl-1"]).toBeLessThan(-0.3)
+	})
+})
+
+// =============================================================================
+// Night
+// =============================================================================
+
+describe("night", () => {
+	const now = tuesday(23)
+	const ctx = makeContext(now)
+
+	test("suppresses ambient items", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", tuesday(9), {
+			signals: { timeRelevance: TimeRelevance.Ambient },
+		})
+		const result = await enhancer([event], ctx)
+
+		expect(result.suppress).toContain("c1")
+	})
+
+	test("demotes calendar events and weather-current", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", makeDate(2025, 7, 9, 9)) // tomorrow
+		const items = [event, weatherCurrent()]
+		const result = await enhancer(items, ctx)
+
+		expect(result.boost!["c1"]).toBeLessThan(0)
+		expect(result.boost!["w-current"]).toBeLessThan(0)
+	})
+
+	test("high-urgency alerts survive unboosted", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const alert = weatherAlert("w-alert", 0.9)
+		const result = await enhancer([alert], ctx)
+
+		// Should not be demoted — either no boost entry or >= 0
+		const alertBoost = result.boost?.["w-alert"] ?? 0
+		expect(alertBoost).toBeGreaterThanOrEqual(0)
+	})
+})
+
+// =============================================================================
+// Pre-meeting window
+// =============================================================================
+
+describe("pre-meeting window", () => {
+	test("boosts upcoming meeting to +0.9", async () => {
+		const now = tuesday(9, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(10))
+		const result = await enhancer([meeting], makeContext(now))
+
+		expect(result.boost!["c1"]).toBe(0.9)
+	})
+
+	test("suppresses low-urgency items during pre-meeting", async () => {
+		const now = tuesday(9, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(10))
+		const lowPriority = weatherHourly()
+		lowPriority.signals = { urgency: 0.1 }
+		const result = await enhancer([meeting, lowPriority], makeContext(now))
+
+		expect(result.suppress).toContain("w-hourly")
+	})
+
+	test("does not suppress items without signals during pre-meeting", async () => {
+		const now = tuesday(9, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(10))
+		const noSignals = weatherDaily()
+		const result = await enhancer([meeting, noSignals], makeContext(now))
+
+		expect(result.suppress ?? []).not.toContain("w-daily")
+	})
+
+	test("boosts TfL alerts during pre-meeting", async () => {
+		const now = tuesday(9, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(10))
+		const result = await enhancer([meeting, tflAlert()], makeContext(now))
+
+		expect(result.boost!["tfl-1"]).toBeGreaterThan(0)
+	})
+
+	test("boosts weather-current if meeting has a location", async () => {
+		const now = tuesday(9, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(10), { location: "Office, London" })
+		const result = await enhancer([meeting, weatherCurrent()], makeContext(now))
+
+		expect(result.boost!["w-current"]).toBeGreaterThan(0)
+	})
+
+	test("works with CalDAV events", async () => {
+		const now = tuesday(9, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = caldavEvent("cd1", tuesday(10))
+		const result = await enhancer([meeting], makeContext(now))
+
+		expect(result.boost!["cd1"]).toBe(0.9)
+	})
+
+	test("does not trigger for events more than 30 minutes away", async () => {
+		const now = tuesday(9)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(10))
+		const result = await enhancer([meeting], makeContext(now))
+
+		// Should not get the +0.9 pre-meeting boost
+		expect(result.boost?.["c1"] ?? 0).not.toBe(0.9)
+	})
+})
+
+// =============================================================================
+// Wind-down gradient
+// =============================================================================
+
+describe("wind-down gradient", () => {
+	test("20:00 weekday: additional -0.1 on work items", async () => {
+		const now = tuesday(20)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		// Non-ambient calendar event — evening rules don't boost or suppress it,
+		// so the only demotion comes from wind-down at 20:00 (-0.1).
+		const event = calendarEvent("c1", makeDate(2025, 7, 9, 9))
+		const result = await enhancer([event], makeContext(now))
+
+		expect(result.boost!["c1"]).toBe(-0.1)
+	})
+
+	test("21:00 weekday: additional -0.2 on work items", async () => {
+		const now = tuesday(21)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const alert = tflAlert("tfl-1", 0.5)
+		const result = await enhancer([alert], makeContext(now))
+
+		// Evening demotes TfL by -0.4, wind-down adds -0.2 = -0.6
+		expect(result.boost!["tfl-1"]).toBeLessThanOrEqual(-0.6)
+	})
+
+	test("21:30 weekday: additional -0.3 on work items", async () => {
+		const now = tuesday(21, 30)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const alert = tflAlert("tfl-1", 0.5)
+		const result = await enhancer([alert], makeContext(now))
+
+		// Evening demotes TfL by -0.4, wind-down adds -0.3 = -0.7
+		expect(result.boost!["tfl-1"]).toBeLessThanOrEqual(-0.7)
+	})
+
+	test("does not apply on weekends", async () => {
+		const now = saturday(21)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const alert = tflAlert("tfl-1", 0.5)
+		const result = await enhancer([alert], makeContext(now))
+
+		// Weekend evening demotes TfL by -0.5, but no wind-down
+		expect(result.boost!["tfl-1"]).toBe(-0.5)
+	})
+})
+
+// =============================================================================
+// Transition lookahead
+// =============================================================================
+
+describe("transition lookahead", () => {
+	test("Saturday 11:40 boosts afternoon-relevant weather-current", async () => {
+		const now = saturday(11, 40)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const items = [weatherCurrent()]
+		const result = await enhancer(items, makeContext(now))
+
+		// Weekend morning boosts weather-current by +0.5.
+		// Transition to afternoon adds +0.2 (weekend afternoon boosts weather-current).
+		expect(result.boost!["w-current"]).toBe(0.7)
+	})
+
+	test("16:40 weekday boosts evening-relevant items (weather-daily)", async () => {
+		const now = tuesday(16, 40)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const items = [weatherDaily()]
+		const result = await enhancer(items, makeContext(now))
+
+		// Afternoon weekday doesn't boost weather-daily, but transition to evening does (+0.2)
+		expect(result.boost!["w-daily"]).toBeGreaterThan(0)
+	})
+
+	test("does not apply when far from boundary", async () => {
+		const now = tuesday(14)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const items = [weatherDaily()]
+		const result = await enhancer(items, makeContext(now))
+
+		// Afternoon weekday doesn't boost or demote weather-daily, and no transition
+		expect(result.boost?.["w-daily"]).toBeUndefined()
+	})
+})
+
+// =============================================================================
+// Weather-time correlation
+// =============================================================================
+
+describe("weather-time correlation", () => {
+	test("morning weekday: extra boost for precipitation", async () => {
+		const now = tuesday(8)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const rainy = weatherCurrentRainy()
+		const dry = weatherCurrent("w-dry")
+		const result = await enhancer([rainy, dry], makeContext(now))
+
+		// Both get morning boost, but rainy gets extra +0.1
+		expect(result.boost!["w-current-rain"]).toBeGreaterThan(result.boost!["w-dry"] ?? 0)
+	})
+
+	test("morning weekday: extra boost for extreme temperature", async () => {
+		const now = tuesday(8)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const extreme = weatherCurrentExtreme()
+		const normal = weatherCurrent("w-normal")
+		const result = await enhancer([extreme, normal], makeContext(now))
+
+		expect(result.boost!["w-current-extreme"]).toBeGreaterThan(result.boost!["w-normal"] ?? 0)
+	})
+
+	test("evening with location event: extra boost for weather-current", async () => {
+		const now = tuesday(19)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const event = calendarEvent("c1", tuesday(19, 30), { location: "The Ivy, London" })
+		const items = [weatherCurrent(), event]
+		const result = await enhancer(items, makeContext(now))
+
+		// Weather-current gets evening weather-time correlation boost (+0.2)
+		// Note: evening weekday doesn't normally boost weather-current
+		expect(result.boost!["w-current"]).toBeGreaterThan(0)
+	})
+
+	test("weather-alert always gets at least +0.5", async () => {
+		const now = tuesday(14) // afternoon — no special weather boost
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const alert = weatherAlert("w-alert", 0.5)
+		const result = await enhancer([alert], makeContext(now))
+
+		expect(result.boost!["w-alert"]).toBeGreaterThanOrEqual(0.5)
+	})
+})
+
+// =============================================================================
+// Edge cases
+// =============================================================================
+
+describe("edge cases", () => {
+	test("empty items returns empty enhancement", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => tuesday(8) })
+		const result = await enhancer([], makeContext(tuesday(8)))
+
+		expect(result).toEqual({})
+	})
+
+	test("unknown item types get no boost", async () => {
+		const enhancer = createTimeOfDayEnhancer({ clock: () => tuesday(8) })
+		const result = await enhancer([unknownItem()], makeContext(tuesday(8)))
+
+		expect(result.boost?.["unknown-1"]).toBeUndefined()
+		expect(result.suppress).toBeUndefined()
+	})
+
+	test("uses context.time when no clock provided", async () => {
+		const enhancer = createTimeOfDayEnhancer()
+		const morningCtx = makeContext(tuesday(8))
+		const items = [weatherCurrent()]
+		const result = await enhancer(items, morningCtx)
+
+		// Should apply morning rules — weather-current boosted
+		expect(result.boost!["w-current"]).toBeGreaterThan(0)
+	})
+
+	test("boost values are clamped to [-1, 1]", async () => {
+		// Morning weekday: TfL alert gets +0.6 from period rules.
+		// Pre-meeting adds +0.5. Total would be +1.1 without clamping.
+		const now = tuesday(8, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(9))
+		const alert = tflAlert("tfl-1", 0.8)
+		const result = await enhancer([meeting, alert], makeContext(now))
+
+		expect(result.boost!["tfl-1"]).toBeLessThanOrEqual(1)
+		expect(result.boost!["tfl-1"]).toBeGreaterThanOrEqual(-1)
+	})
+
+	test("suppress list is deduplicated", async () => {
+		// An item that would be suppressed by both evening rules and pre-meeting low-urgency
+		const now = tuesday(19, 45)
+		const enhancer = createTimeOfDayEnhancer({ clock: () => now })
+		const meeting = calendarEvent("c1", tuesday(20))
+		const ambientEvent = calendarEvent("c2", tuesday(9), {
+			signals: { urgency: 0.1, timeRelevance: TimeRelevance.Ambient },
+		})
+		const result = await enhancer([meeting, ambientEvent], makeContext(now))
+
+		if (result.suppress) {
+			const c2Count = result.suppress.filter((id) => id === "c2").length
+			expect(c2Count).toBeLessThanOrEqual(1)
+		}
+	})
+})

packages/aris-feed-enhancers/src/time-of-day-enhancer.ts

@@ -0,0 +1,595 @@
+import type { Context, FeedEnhancement, FeedItem, FeedPostProcessor } from "@aris/core"
+
+import { TimeRelevance } from "@aris/core"
+
+import type { CalDavEventData } from "@aris/source-caldav"
+import type { CalendarEventData } from "@aris/source-google-calendar"
+import type { CurrentWeatherData } from "@aris/source-weatherkit"
+
+import { CalDavFeedItemType } from "@aris/source-caldav"
+import { CalendarFeedItemType } from "@aris/source-google-calendar"
+import { TflFeedItemType } from "@aris/source-tfl"
+import { WeatherFeedItemType } from "@aris/source-weatherkit"
+
+
+export const TimePeriod = {
+	Morning: "morning",
+	Afternoon: "afternoon",
+	Evening: "evening",
+	Night: "night",
+} as const
+
+export type TimePeriod = (typeof TimePeriod)[keyof typeof TimePeriod]
+
+export const DayType = {
+	Weekday: "weekday",
+	Weekend: "weekend",
+} as const
+
+export type DayType = (typeof DayType)[keyof typeof DayType]
+
+
+const PRE_MEETING_WINDOW_MS = 30 * 60 * 1000
+const TRANSITION_WINDOW_MS = 30 * 60 * 1000
+
+const PERIOD_BOUNDARIES = [
+	{ hour: 6, period: TimePeriod.Morning },
+	{ hour: 12, period: TimePeriod.Afternoon },
+	{ hour: 17, period: TimePeriod.Evening },
+	{ hour: 22, period: TimePeriod.Night },
+] as const
+
+/** All calendar event types across sources */
+const CALENDAR_EVENT_TYPES: ReadonlySet<string> = new Set([
+	CalendarFeedItemType.Event,
+	CalDavFeedItemType.Event,
+])
+
+/**
+ * Creates a post-processor that reranks feed items based on time of day.
+ *
+ * Prioritizes items that matter right now and pushes down items that don't:
+ *
+ * - Morning: weather and first meeting rise, hourly forecasts sink.
+ *   Weekends flip — weather stays up but work calendar and commute alerts drop.
+ * - Afternoon: imminent meetings rise. Stale weather sinks.
+ * - Evening: work calendar is suppressed, tomorrow's forecast and personal
+ *   events rise. Weekends suppress work more aggressively.
+ * - Night: almost everything sinks except high-urgency alerts.
+ * - Pre-meeting (30 min before any event): that meeting dominates, low-urgency
+ *   noise is suppressed, commute/weather context rises if the meeting has a location.
+ * - Wind-down (weekday 20–22h): work items progressively sink as night approaches.
+ * - Transition lookahead (30 min before a period boundary): items relevant to
+ *   the next period get a head start.
+ * - Weather-time correlation: precipitation boosts morning weather, evening
+ *   events with locations boost current weather, alerts always stay high.
+ */
+export interface TimeOfDayEnhancerOptions {
+	/** Override clock for testing. Defaults to reading context.time. */
+	clock?: () => Date
+}
+
+export function createTimeOfDayEnhancer(options?: TimeOfDayEnhancerOptions): FeedPostProcessor {
+	const clock = options?.clock
+
+	function timeOfDayEnhancer(items: FeedItem[], context: Context): Promise<FeedEnhancement> {
+		if (items.length === 0) return Promise.resolve({})
+
+		const now = clock ? clock() : context.time
+		const period = getTimePeriod(now)
+		const dayType = getDayType(now)
+		const boost: Record<string, number> = {}
+		const suppress: string[] = []
+
+		// 1. Apply period-based rules
+		const firstEventId = findFirstEventOfDay(items, now)
+
+		switch (period) {
+			case TimePeriod.Morning:
+				if (dayType === DayType.Weekday) {
+					applyMorningWeekday(items, boost, firstEventId)
+				} else {
+					applyMorningWeekend(items, boost)
+				}
+				break
+			case TimePeriod.Afternoon:
+				if (dayType === DayType.Weekday) {
+					applyAfternoonWeekday(items, boost)
+				} else {
+					applyAfternoonWeekend(items, boost)
+				}
+				break
+			case TimePeriod.Evening:
+				if (dayType === DayType.Weekday) {
+					applyEveningWeekday(items, boost, suppress)
+				} else {
+					applyEveningWeekend(items, boost, suppress)
+				}
+				break
+			case TimePeriod.Night:
+				applyNight(items, boost, suppress)
+				break
+		}
+
+		// 2. Pre-meeting overrides (can override period rules)
+		const preMeeting = detectPreMeetingItems(items, now)
+		applyPreMeetingOverrides(items, preMeeting, boost, suppress)
+
+		// 3. Wind-down gradient
+		applyWindDown(items, now, dayType, boost)
+
+		// 4. Transition lookahead
+		applyTransitionLookahead(items, now, period, dayType, boost)
+
+		// 5. Weather-time correlation
+		const eveningLocation = hasEveningCalendarEventWithLocation(items, now)
+		applyWeatherTimeCorrelation(items, period, dayType, eveningLocation, boost)
+
+		// Clamp boost values to [-1, 1] — additive layers can exceed the range
+		for (const id in boost) {
+			boost[id] = Math.max(-1, Math.min(1, boost[id]!))
+		}
+
+		const result: FeedEnhancement = {}
+		if (Object.keys(boost).length > 0) {
+			result.boost = boost
+		}
+		const uniqueSuppress = [...new Set(suppress)]
+		if (uniqueSuppress.length > 0) {
+			result.suppress = uniqueSuppress
+		}
+		return Promise.resolve(result)
+	}
+
+	return timeOfDayEnhancer
+}
+
+
+export function getTimePeriod(date: Date): TimePeriod {
+	const hour = date.getHours()
+	if (hour >= 22 || hour < 6) return TimePeriod.Night
+	if (hour >= 17) return TimePeriod.Evening
+	if (hour >= 12) return TimePeriod.Afternoon
+	return TimePeriod.Morning
+}
+
+export function getDayType(date: Date): DayType {
+	const day = date.getDay()
+	return day === 0 || day === 6 ? DayType.Weekend : DayType.Weekday
+}
+
+/**
+ * Returns the next period boundary as { hour, period } and the ms until it.
+ */
+function getNextPeriodBoundary(date: Date): { period: TimePeriod; msUntil: number } {
+	const hour = date.getHours()
+	const minuteMs = date.getMinutes() * 60_000 + date.getSeconds() * 1000 + date.getMilliseconds()
+
+	for (const boundary of PERIOD_BOUNDARIES) {
+		if (hour < boundary.hour) {
+			const msUntil = (boundary.hour - hour) * 3_600_000 - minuteMs
+			return { period: boundary.period, msUntil }
+		}
+	}
+
+	// Past 22:00 — next boundary is morning at 06:00
+	const hoursUntil6 = (24 - hour + 6) * 3_600_000 - minuteMs
+	return { period: TimePeriod.Morning, msUntil: hoursUntil6 }
+}
+
+/**
+ * Extract start time from calendar event data.
+ * Google Calendar uses `startTime`, CalDAV uses `startDate`.
+ */
+function getEventStartTime(data: CalendarEventData | CalDavEventData): Date {
+	return "startTime" in data ? (data as CalendarEventData).startTime : (data as CalDavEventData).startDate
+}
+
+/**
+ * Check if a current weather item indicates precipitation or extreme conditions.
+ * Only meaningful for weather-current items.
+ */
+function hasPrecipitationOrExtreme(item: FeedItem): boolean {
+	const data = item.data as CurrentWeatherData
+	if (data.precipitationIntensity > 0) return true
+	if (data.temperature < 0 || data.temperature > 35) return true
+	return false
+}
+
+
+interface PreMeetingInfo {
+	/** IDs of calendar items starting within the pre-meeting window */
+	upcomingMeetingIds: Set<string>
+	/** Whether any upcoming meeting has a location */
+	hasLocationMeeting: boolean
+}
+
+function detectPreMeetingItems(items: FeedItem[], now: Date): PreMeetingInfo {
+	const nowMs = now.getTime()
+	const upcomingMeetingIds = new Set<string>()
+	let hasLocationMeeting = false
+
+	for (const item of items) {
+		if (!CALENDAR_EVENT_TYPES.has(item.type)) continue
+
+		const data = item.data as CalendarEventData | CalDavEventData
+		const msUntil = getEventStartTime(data).getTime() - nowMs
+		if (msUntil > 0 && msUntil <= PRE_MEETING_WINDOW_MS) {
+			upcomingMeetingIds.add(item.id)
+			if (data.location) {
+				hasLocationMeeting = true
+			}
+		}
+	}
+
+	return { upcomingMeetingIds, hasLocationMeeting }
+}
+
+
+function findFirstEventOfDay(items: FeedItem[], now: Date): string | null {
+	let earliest: { id: string; time: number } | null = null
+
+	for (const item of items) {
+		if (!CALENDAR_EVENT_TYPES.has(item.type)) continue
+
+		const data = item.data as CalendarEventData | CalDavEventData
+		const startTime = getEventStartTime(data)
+		const startMs = startTime.getTime()
+
+		// Must be today and in the future
+		const sameDay =
+			startTime.getFullYear() === now.getFullYear() &&
+			startTime.getMonth() === now.getMonth() &&
+			startTime.getDate() === now.getDate()
+		if (!sameDay) continue
+		if (startMs <= now.getTime()) continue
+
+		if (!earliest || startMs < earliest.time) {
+			earliest = { id: item.id, time: startMs }
+		}
+	}
+
+	return earliest?.id ?? null
+}
+
+
+function applyMorningWeekday(
+	items: FeedItem[],
+	boost: Record<string, number>,
+	firstEventId: string | null,
+): void {
+	for (const item of items) {
+		switch (item.type) {
+			case WeatherFeedItemType.Current:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.7
+				break
+			case WeatherFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.8
+				break
+			case WeatherFeedItemType.Hourly:
+			case WeatherFeedItemType.Daily:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.3
+				break
+			case TflFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.6
+				break
+		}
+	}
+
+	if (firstEventId) {
+		boost[firstEventId] = (boost[firstEventId] ?? 0) + 0.6
+	}
+}
+
+function applyMorningWeekend(items: FeedItem[], boost: Record<string, number>): void {
+	for (const item of items) {
+		switch (item.type) {
+			case WeatherFeedItemType.Current:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.5
+				break
+			case WeatherFeedItemType.Daily:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.4
+				break
+			case CalendarFeedItemType.Event:
+			case CalDavFeedItemType.Event:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.4
+				break
+			case TflFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.3
+				break
+		}
+	}
+}
+
+function applyAfternoonWeekday(items: FeedItem[], boost: Record<string, number>): void {
+	for (const item of items) {
+		switch (item.type) {
+			case CalendarFeedItemType.Event:
+			case CalDavFeedItemType.Event:
+				if (item.signals?.timeRelevance === TimeRelevance.Imminent) {
+					boost[item.id] = (boost[item.id] ?? 0) + 0.5
+				}
+				break
+			case WeatherFeedItemType.Current:
+			case WeatherFeedItemType.Hourly:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.2
+				break
+		}
+	}
+}
+
+function applyAfternoonWeekend(items: FeedItem[], boost: Record<string, number>): void {
+	for (const item of items) {
+		switch (item.type) {
+			case WeatherFeedItemType.Current:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.3
+				break
+			case CalendarFeedItemType.Event:
+			case CalDavFeedItemType.Event:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.5
+				break
+			case TflFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.2
+				break
+		}
+	}
+}
+
+function applyEveningWeekday(
+	items: FeedItem[],
+	boost: Record<string, number>,
+	suppress: string[],
+): void {
+	for (const item of items) {
+		switch (item.type) {
+			case CalendarFeedItemType.Event:
+			case CalDavFeedItemType.Event:
+				if (item.signals?.timeRelevance === TimeRelevance.Ambient) {
+					suppress.push(item.id)
+				}
+				break
+			case TflFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.4
+				break
+			case WeatherFeedItemType.Daily:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.3
+				break
+			case CalendarFeedItemType.AllDay:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.3
+				break
+		}
+	}
+}
+
+function applyEveningWeekend(
+	items: FeedItem[],
+	boost: Record<string, number>,
+	suppress: string[],
+): void {
+	for (const item of items) {
+		switch (item.type) {
+			case WeatherFeedItemType.Current:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.3
+				break
+			case CalendarFeedItemType.Event:
+			case CalDavFeedItemType.Event:
+				if (item.signals?.timeRelevance === TimeRelevance.Ambient) {
+					suppress.push(item.id)
+				}
+				break
+			case TflFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.5
+				break
+		}
+	}
+}
+
+function applyNight(items: FeedItem[], boost: Record<string, number>, suppress: string[]): void {
+	for (const item of items) {
+		// Suppress all ambient items
+		if (item.signals?.timeRelevance === TimeRelevance.Ambient) {
+			suppress.push(item.id)
+			continue
+		}
+
+		// High-urgency alerts survive unboosted
+		if (
+			(item.type === WeatherFeedItemType.Alert || item.type === TflFeedItemType.Alert) &&
+			(item.signals?.urgency ?? 0) >= 0.8
+		) {
+			continue
+		}
+
+		// Demote everything else
+		switch (item.type) {
+			case CalendarFeedItemType.Event:
+			case CalendarFeedItemType.AllDay:
+			case CalDavFeedItemType.Event:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.6
+				break
+			case WeatherFeedItemType.Current:
+			case WeatherFeedItemType.Hourly:
+				boost[item.id] = (boost[item.id] ?? 0) - 0.5
+				break
+		}
+	}
+}
+
+
+function applyPreMeetingOverrides(
+	items: FeedItem[],
+	preMeeting: PreMeetingInfo,
+	boost: Record<string, number>,
+	suppress: string[],
+): void {
+	if (preMeeting.upcomingMeetingIds.size === 0) return
+
+	// Intentional override, not additive — the upcoming meeting should dominate
+	// regardless of what period rules assigned. Don't reorder this before period rules.
+	for (const meetingId of preMeeting.upcomingMeetingIds) {
+		boost[meetingId] = 0.9
+	}
+
+	for (const item of items) {
+		if (preMeeting.upcomingMeetingIds.has(item.id)) continue
+
+		switch (item.type) {
+			case TflFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) + 0.5
+				break
+			case WeatherFeedItemType.Current:
+				if (preMeeting.hasLocationMeeting) {
+					boost[item.id] = (boost[item.id] ?? 0) + 0.4
+				}
+				break
+		}
+
+		// Suppress items that explicitly declare low urgency.
+		// Items without signals are left alone — absence of urgency is not low urgency.
+		if (item.signals && item.signals.urgency !== undefined && item.signals.urgency < 0.3) {
+			suppress.push(item.id)
+		}
+	}
+}
+
+function applyWindDown(
+	items: FeedItem[],
+	now: Date,
+	dayType: DayType,
+	boost: Record<string, number>,
+): void {
+	if (dayType !== DayType.Weekday) return
+
+	const hour = now.getHours()
+	const minutes = now.getMinutes()
+
+	if (hour < 20 || hour >= 22) return
+
+	// Gradient: 20:00 → -0.1, 21:00 → -0.2, 21:30+ → -0.3
+	let additionalDemotion: number
+	if (hour === 20) {
+		additionalDemotion = -0.1
+	} else if (hour === 21 && minutes < 30) {
+		additionalDemotion = -0.2
+	} else {
+		additionalDemotion = -0.3
+	}
+
+	for (const item of items) {
+		switch (item.type) {
+			case CalendarFeedItemType.Event:
+			case CalendarFeedItemType.AllDay:
+			case CalDavFeedItemType.Event:
+			case TflFeedItemType.Alert:
+				boost[item.id] = (boost[item.id] ?? 0) + additionalDemotion
+				break
+		}
+	}
+}
+
+
+function applyTransitionLookahead(
+	items: FeedItem[],
+	now: Date,
+	currentPeriod: TimePeriod,
+	dayType: DayType,
+	boost: Record<string, number>,
+): void {
+	const next = getNextPeriodBoundary(now)
+	if (next.msUntil > TRANSITION_WINDOW_MS) return
+
+	// Apply a +0.2 secondary boost to items that would be boosted in the next period
+	const nextPeriodBoost = getNextPeriodBoostTargets(next.period, dayType)
+
+	for (const item of items) {
+		if (nextPeriodBoost.has(item.type)) {
+			boost[item.id] = (boost[item.id] ?? 0) + 0.2
+		}
+	}
+}
+
+/**
+ * Returns the set of item types that get boosted in a given period+dayType.
+ */
+function getNextPeriodBoostTargets(period: TimePeriod, dayType: DayType): ReadonlySet<string> {
+	const targets = new Set<string>()
+
+	switch (period) {
+		case TimePeriod.Morning:
+			targets.add(WeatherFeedItemType.Current)
+			if (dayType === DayType.Weekday) {
+				targets.add(WeatherFeedItemType.Alert)
+				targets.add(TflFeedItemType.Alert)
+			} else {
+				targets.add(WeatherFeedItemType.Daily)
+			}
+			break
+		case TimePeriod.Afternoon:
+			if (dayType === DayType.Weekend) {
+				targets.add(WeatherFeedItemType.Current)
+			}
+			break
+		case TimePeriod.Evening:
+			targets.add(WeatherFeedItemType.Daily)
+			if (dayType === DayType.Weekend) {
+				targets.add(WeatherFeedItemType.Current)
+			}
+			break
+		case TimePeriod.Night:
+			// Night doesn't boost much — transition toward night means demoting,
+			// which is handled by wind-down. No positive targets here.
+			break
+	}
+
+	return targets
+}
+
+
+function applyWeatherTimeCorrelation(
+	items: FeedItem[],
+	period: TimePeriod,
+	dayType: DayType,
+	hasEveningEventWithLocation: boolean,
+	boost: Record<string, number>,
+): void {
+	for (const item of items) {
+		switch (item.type) {
+			case WeatherFeedItemType.Alert: {
+				const current = boost[item.id] ?? 0
+				if (current < 0.5) {
+					boost[item.id] = 0.5
+				}
+				break
+			}
+			case WeatherFeedItemType.Current:
+				if (period === TimePeriod.Morning && dayType === DayType.Weekday && hasPrecipitationOrExtreme(item)) {
+					boost[item.id] = (boost[item.id] ?? 0) + 0.1
+				}
+				if (period === TimePeriod.Evening && hasEveningEventWithLocation) {
+					boost[item.id] = (boost[item.id] ?? 0) + 0.2
+				}
+				break
+		}
+	}
+}
+
+function hasEveningCalendarEventWithLocation(items: FeedItem[], now: Date): boolean {
+	const todayEvening17 = new Date(now)
+	todayEvening17.setHours(17, 0, 0, 0)
+	const todayNight22 = new Date(now)
+	todayNight22.setHours(22, 0, 0, 0)
+
+	for (const item of items) {
+		if (!CALENDAR_EVENT_TYPES.has(item.type)) continue
+
+		const data = item.data as CalendarEventData | CalDavEventData
+		const startMs = getEventStartTime(data).getTime()
+		if (startMs >= todayEvening17.getTime() && startMs < todayNight22.getTime()) {
+			if (data.location) return true
+		}
+	}
+
+	return false
+}
+
+

packages/aris-source-caldav/fixtures/daily-recurring-allday.ics

@@ -0,0 +1,12 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:daily-allday-001@test
+DTSTART;VALUE=DATE:20260112
+DTEND;VALUE=DATE:20260113
+SUMMARY:Daily Reminder
+RRULE:FREQ=DAILY;COUNT=7
+STATUS:CONFIRMED
+END:VEVENT
+END:VCALENDAR

packages/aris-source-caldav/fixtures/weekly-recurring-with-exception.ics

@@ -0,0 +1,20 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:weekly-exc-001@test
+DTSTART:20260101T140000Z
+DTEND:20260101T150000Z
+SUMMARY:Standup
+RRULE:FREQ=WEEKLY;BYDAY=TH;COUNT=8
+STATUS:CONFIRMED
+END:VEVENT
+BEGIN:VEVENT
+UID:weekly-exc-001@test
+RECURRENCE-ID:20260115T140000Z
+DTSTART:20260115T160000Z
+DTEND:20260115T170000Z
+SUMMARY:Standup (rescheduled)
+STATUS:CONFIRMED
+END:VEVENT
+END:VCALENDAR

packages/aris-source-caldav/fixtures/weekly-recurring.ics

@@ -0,0 +1,13 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:weekly-001@test
+DTSTART:20260101T100000Z
+DTEND:20260101T110000Z
+SUMMARY:Weekly Team Meeting
+RRULE:FREQ=WEEKLY;BYDAY=TH;COUNT=10
+LOCATION:Room B
+STATUS:CONFIRMED
+END:VEVENT
+END:VCALENDAR

packages/aris-source-caldav/scripts/test-live.ts

@@ -3,8 +3,15 @@
  *
  * Usage:
  *   bun run test-live.ts
+ *
+ * Writes feed items (with slots) to scripts/.cache/feed-items.json for inspection.
  */
 
+import { mkdirSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { Context } from "@aris/core"
+
 import { CalDavSource } from "../src/index.ts"
 
 const serverUrl = prompt("CalDAV server URL:")
@@ -27,7 +34,7 @@ const source = new CalDavSource({
 	lookAheadDays,
 })
 
-const context = { time: new Date() }
+const context = new Context()
 
 console.log(`\nFetching from ${serverUrl} as ${username} (lookAheadDays=${lookAheadDays})...\n`)
 
@@ -49,6 +56,9 @@ for (const item of items) {
 	console.log(`  Status:     ${item.data.status ?? "(none)"}`)
 	console.log(`  Urgency:    ${item.signals?.urgency}`)
 	console.log(`  Relevance:  ${item.signals?.timeRelevance}`)
+	if (item.slots) {
+		console.log(`  Slots:      ${Object.keys(item.slots).join(", ")}`)
+	}
 	if (item.data.attendees.length > 0) {
 		console.log(`  Attendees:  ${item.data.attendees.map((a) => a.name ?? a.email).join(", ")}`)
 	}
@@ -60,3 +70,11 @@ for (const item of items) {
 if (items.length === 0) {
 	console.log("(no events found in the time window)")
 }
+
+// Write feed items to .cache for slot testing
+const cacheDir = join(import.meta.dir, ".cache")
+mkdirSync(cacheDir, { recursive: true })
+
+const outPath = join(cacheDir, "feed-items.json")
+writeFileSync(outPath, JSON.stringify(items, null, 2))
+console.log(`\nFeed items written to ${outPath}`)

packages/aris-source-caldav/src/caldav-source.test.ts

@@ -1,6 +1,6 @@
-import type { Context } from "@aris/core"
+import type { ContextEntry } from "@aris/core"
 
-import { TimeRelevance, contextValue } from "@aris/core"
+import { Context, TimeRelevance } from "@aris/core"
 import { describe, expect, test } from "bun:test"
 import { readFileSync } from "node:fs"
 import { join } from "node:path"
@@ -13,14 +13,21 @@ import type {
 } from "./types.ts"
 
 import { CalDavSource, computeSignals } from "./caldav-source.ts"
-import { CalDavCalendarKey } from "./calendar-context.ts"
+import { CalDavCalendarKey, type CalendarContext } from "./calendar-context.ts"
 
 function loadFixture(name: string): string {
 	return readFileSync(join(import.meta.dir, "..", "fixtures", name), "utf-8")
 }
 
 function createContext(time: Date): Context {
-	return { time }
+	return new Context(time)
+}
+
+/** Extract the CalendarContext value from fetchContext entries. */
+function extractCalendar(entries: readonly ContextEntry[] | null): CalendarContext | undefined {
+	if (!entries) return undefined
+	const entry = entries.find(([key]) => key === CalDavCalendarKey)
+	return entry?.[1] as CalendarContext | undefined
 }
 
 class MockDAVClient implements CalDavDAVClient {
@@ -201,7 +208,7 @@ describe("CalDavSource", () => {
 		expect(items[0]!.data.calendarName).toBeNull()
 	})
 
-	test("handles recurring events with exceptions", async () => {
+	test("expands recurring events within the time range", async () => {
 		const objects: Record<string, CalDavDAVObject[]> = {
 			"/cal/work": [
 				{
@@ -211,21 +218,42 @@ describe("CalDavSource", () => {
 			],
 		}
 		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		// lookAheadDays=0 → range is Jan 15 only
 		const source = createSource(client)
 
 		const items = await source.fetchItems(createContext(new Date("2026-01-15T08:00:00Z")))
 
-		expect(items).toHaveLength(2)
+		// Only the Jan 15 occurrence falls in the single-day window
+		expect(items).toHaveLength(1)
+		expect(items[0]!.data.title).toBe("Weekly Sync")
+		expect(items[0]!.data.startDate).toEqual(new Date("2026-01-15T09:00:00Z"))
+	})
 
-		const base = items.find((i) => i.data.title === "Weekly Sync")
+	test("includes exception overrides when they fall in range", async () => {
+		const objects: Record<string, CalDavDAVObject[]> = {
+			"/cal/work": [
+				{
+					url: "/cal/work/recurring.ics",
+					data: loadFixture("recurring-event.ics"),
+				},
+			],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		// lookAheadDays=8 → range covers Jan 15 through Jan 23, includes the Jan 22 exception
+		const source = createSource(client, 8)
+
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T08:00:00Z")))
+
+		const base = items.filter((i) => i.data.title === "Weekly Sync")
 		const exception = items.find((i) => i.data.title === "Weekly Sync (moved)")
 
-		expect(base).toBeDefined()
+		// Jan 15 base occurrence
-		expect(base!.data.recurrenceId).toBeNull()
+		expect(base.length).toBeGreaterThanOrEqual(1)
 
+		// Jan 22 exception replaces the base occurrence
 		expect(exception).toBeDefined()
-		expect(exception!.data.recurrenceId).not.toBeNull()
+		expect(exception!.data.startDate).toEqual(new Date("2026-01-22T10:00:00Z"))
-		expect(exception!.id).toContain("-")
+		expect(exception!.data.endDate).toEqual(new Date("2026-01-22T10:30:00Z"))
 	})
 
 	test("caches events within the same refresh cycle", async () => {
@@ -302,8 +330,8 @@ describe("CalDavSource.fetchContext", () => {
 	test("returns empty context when no calendars exist", async () => {
 		const client = new MockDAVClient([], {})
 		const source = createSource(client)
-		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
+		const calendar = extractCalendar(entries)
 
 		expect(calendar).toBeDefined()
 		expect(calendar!.inProgress).toEqual([])
@@ -320,8 +348,8 @@ describe("CalDavSource.fetchContext", () => {
 		const source = createSource(client)
 
 		// 14:30 is during the 14:00-15:00 event
-		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T14:30:00Z")))
+		const entries = await source.fetchContext(createContext(new Date("2026-01-15T14:30:00Z")))
-		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
+		const calendar = extractCalendar(entries)
 
 		expect(calendar!.inProgress).toHaveLength(1)
 		expect(calendar!.inProgress[0]!.title).toBe("Team Standup")
@@ -335,8 +363,8 @@ describe("CalDavSource.fetchContext", () => {
 		const source = createSource(client)
 
 		// 12:00 is before the 14:00 event
-		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
+		const calendar = extractCalendar(entries)
 
 		expect(calendar!.inProgress).toHaveLength(0)
 		expect(calendar!.nextEvent).not.toBeNull()
@@ -350,8 +378,8 @@ describe("CalDavSource.fetchContext", () => {
 		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
 		const source = createSource(client)
 
-		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
+		const calendar = extractCalendar(entries)
 
 		expect(calendar!.inProgress).toHaveLength(0)
 		expect(calendar!.nextEvent).toBeNull()
@@ -369,8 +397,8 @@ describe("CalDavSource.fetchContext", () => {
 		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
 		const source = createSource(client)
 
-		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
+		const calendar = extractCalendar(entries)
 
 		expect(calendar!.todayEventCount).toBe(2)
 		expect(calendar!.hasTodayEvents).toBe(true)
@@ -505,3 +533,5 @@ describe("computeSignals", () => {
 		expect(computeSignals(event, now, "Asia/Tokyo").urgency).toBe(0.2)
 	})
 })
+
+

packages/aris-source-caldav/src/caldav-source.ts

@@ -1,6 +1,6 @@
-import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { TimeRelevance, UnknownActionError } from "@aris/core"
+import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
 import { DAVClient } from "tsdav"
 
 import type { CalDavDAVClient, CalDavEventData, CalDavFeedItem } from "./types.ts"
@@ -93,17 +93,20 @@ export class CalDavSource implements FeedSource<CalDavFeedItem> {
 		throw new UnknownActionError(actionId)
 	}
 
-	async fetchContext(context: Context): Promise<Partial<Context> | null> {
+	async fetchContext(context: Context): Promise<readonly ContextEntry[] | null> {
 		const events = await this.fetchEvents(context)
 		if (events.length === 0) {
-			return {
+			return [
-				[CalDavCalendarKey]: {
+				[
-					inProgress: [],
+					CalDavCalendarKey,
-					nextEvent: null,
+					{
-					hasTodayEvents: false,
+						inProgress: [],
-					todayEventCount: 0,
+						nextEvent: null,
-				},
+						hasTodayEvents: false,
-			}
+						todayEventCount: 0,
+					},
+				],
+			]
 		}
 
 		const now = context.time
@@ -121,7 +124,7 @@ export class CalDavSource implements FeedSource<CalDavFeedItem> {
 			todayEventCount: events.length,
 		}
 
-		return { [CalDavCalendarKey]: calendarContext }
+		return [[CalDavCalendarKey, calendarContext]]
 	}
 
 	async fetchItems(context: Context): Promise<CalDavFeedItem[]> {
@@ -181,7 +184,7 @@ export class CalDavSource implements FeedSource<CalDavFeedItem> {
 			for (const obj of objects) {
 				if (typeof obj.data !== "string") continue
 
-				const events = parseICalEvents(obj.data, calendarName)
+				const events = parseICalEvents(obj.data, calendarName, { start, end })
 				for (const event of events) {
 					allEvents.push(event)
 				}

packages/aris-source-caldav/src/calendar-context.ts

@@ -21,4 +21,4 @@ export interface CalendarContext {
 	todayEventCount: number
 }
 
-export const CalDavCalendarKey: ContextKey<CalendarContext> = contextKey("caldavCalendar")
+export const CalDavCalendarKey: ContextKey<CalendarContext> = contextKey("aris.caldav", "calendar")

packages/aris-source-caldav/src/ical-parser.test.ts

@@ -105,3 +105,94 @@ describe("parseICalEvents", () => {
 		expect(events[0]!.status).toBe("cancelled")
 	})
 })
+
+describe("parseICalEvents with timeRange (recurrence expansion)", () => {
+	test("expands weekly recurring event into occurrences within range", () => {
+		// weekly-recurring.ics: DTSTART 2026-01-01 (Thu), FREQ=WEEKLY;BYDAY=TH;COUNT=10
+		// Occurrences: Jan 1, 8, 15, 22, 29, Feb 5, 12, 19, 26, Mar 5
+		// Query window: Jan 14 – Jan 23 → should get Jan 15 and Jan 22
+		const events = parseICalEvents(loadFixture("weekly-recurring.ics"), "Work", {
+			start: new Date("2026-01-14T00:00:00Z"),
+			end: new Date("2026-01-23T00:00:00Z"),
+		})
+
+		expect(events).toHaveLength(2)
+		expect(events[0]!.startDate).toEqual(new Date("2026-01-15T10:00:00Z"))
+		expect(events[0]!.endDate).toEqual(new Date("2026-01-15T11:00:00Z"))
+		expect(events[1]!.startDate).toEqual(new Date("2026-01-22T10:00:00Z"))
+		expect(events[1]!.endDate).toEqual(new Date("2026-01-22T11:00:00Z"))
+
+		// All occurrences share the same UID and metadata
+		for (const event of events) {
+			expect(event.uid).toBe("weekly-001@test")
+			expect(event.title).toBe("Weekly Team Meeting")
+			expect(event.location).toBe("Room B")
+			expect(event.calendarName).toBe("Work")
+		}
+	})
+
+	test("returns empty array when no occurrences fall in range", () => {
+		// Query window: Dec 2025 — before the first occurrence
+		const events = parseICalEvents(loadFixture("weekly-recurring.ics"), null, {
+			start: new Date("2025-12-01T00:00:00Z"),
+			end: new Date("2025-12-31T00:00:00Z"),
+		})
+
+		expect(events).toHaveLength(0)
+	})
+
+	test("applies exception overrides during expansion", () => {
+		// weekly-recurring-with-exception.ics:
+		//   Master: DTSTART 2026-01-01 (Thu) 14:00, FREQ=WEEKLY;BYDAY=TH;COUNT=8
+		//   Exception: RECURRENCE-ID 2026-01-15T14:00 → moved to 16:00-17:00, title changed
+		// Query window: Jan 14 – Jan 16 → should get the exception occurrence for Jan 15
+		const events = parseICalEvents(loadFixture("weekly-recurring-with-exception.ics"), "Work", {
+			start: new Date("2026-01-14T00:00:00Z"),
+			end: new Date("2026-01-16T00:00:00Z"),
+		})
+
+		expect(events).toHaveLength(1)
+		expect(events[0]!.title).toBe("Standup (rescheduled)")
+		expect(events[0]!.startDate).toEqual(new Date("2026-01-15T16:00:00Z"))
+		expect(events[0]!.endDate).toEqual(new Date("2026-01-15T17:00:00Z"))
+	})
+
+	test("expands recurring all-day events", () => {
+		// daily-recurring-allday.ics: DTSTART 2026-01-12, FREQ=DAILY;COUNT=7
+		// Occurrences: Jan 12, 13, 14, 15, 16, 17, 18
+		// Query window: Jan 14 – Jan 17 → should get Jan 14, 15, 16
+		const events = parseICalEvents(loadFixture("daily-recurring-allday.ics"), null, {
+			start: new Date("2026-01-14T00:00:00Z"),
+			end: new Date("2026-01-17T00:00:00Z"),
+		})
+
+		expect(events).toHaveLength(3)
+		for (const event of events) {
+			expect(event.isAllDay).toBe(true)
+			expect(event.title).toBe("Daily Reminder")
+		}
+	})
+
+	test("non-recurring events are filtered by range", () => {
+		// single-event.ics: 2026-01-15T14:00 – 15:00
+		// Query window that includes it
+		const included = parseICalEvents(loadFixture("single-event.ics"), null, {
+			start: new Date("2026-01-15T00:00:00Z"),
+			end: new Date("2026-01-16T00:00:00Z"),
+		})
+		expect(included).toHaveLength(1)
+
+		// Query window that excludes it
+		const excluded = parseICalEvents(loadFixture("single-event.ics"), null, {
+			start: new Date("2026-01-16T00:00:00Z"),
+			end: new Date("2026-01-17T00:00:00Z"),
+		})
+		expect(excluded).toHaveLength(0)
+	})
+
+	test("without timeRange, recurring events return raw VEVENTs (legacy)", () => {
+		// Legacy behavior: no expansion, just returns the VEVENT components as-is
+		const events = parseICalEvents(loadFixture("recurring-event.ics"), "Team")
+		expect(events).toHaveLength(2)
+	})
+})

packages/aris-source-caldav/src/ical-parser.ts

@@ -9,21 +9,191 @@ import {
 	type CalDavEventData,
 } from "./types.ts"
 
+export interface ICalTimeRange {
+	start: Date
+	end: Date
+}
+
 /**
- * Parses a raw iCalendar string and extracts all VEVENT components
+ * Safety cap to prevent runaway iteration on pathological recurrence rules.
+ * Each iteration is pure date math (no I/O), so a high cap is fine.
+ * 10,000 covers a daily event with DTSTART ~27 years in the past.
+ */
+const MAX_RECURRENCE_ITERATIONS = 10_000
+
+/**
+ * Parses a raw iCalendar string and extracts VEVENT components
  * into CalDavEventData objects.
  *
+ * When a timeRange is provided, recurring events are expanded into
+ * individual occurrences within that range. Without a timeRange,
+ * each VEVENT component is returned as-is (legacy behavior).
+ *
  * @param icsData - Raw iCalendar string from a CalDAV response
  * @param calendarName - Display name of the calendar this event belongs to
+ * @param timeRange - When set, expand recurrences and filter to this window
  */
-export function parseICalEvents(icsData: string, calendarName: string | null): CalDavEventData[] {
+export function parseICalEvents(
+	icsData: string,
+	calendarName: string | null,
+	timeRange?: ICalTimeRange,
+): CalDavEventData[] {
 	const jcal = ICAL.parse(icsData)
 	const comp = new ICAL.Component(jcal)
 	const vevents = comp.getAllSubcomponents("vevent")
 
-	return vevents.map((vevent: InstanceType<typeof ICAL.Component>) =>
+	if (!timeRange) {
-		parseVEvent(vevent, calendarName),
+		return vevents.map((vevent: InstanceType<typeof ICAL.Component>) =>
-	)
+			parseVEvent(vevent, calendarName),
+		)
+	}
+
+	// Group VEVENTs by UID: master + exceptions
+	const byUid = new Map<
+		string,
+		{
+			master: InstanceType<typeof ICAL.Component> | null
+			exceptions: InstanceType<typeof ICAL.Component>[]
+		}
+	>()
+
+	for (const vevent of vevents as InstanceType<typeof ICAL.Component>[]) {
+		const uid = vevent.getFirstPropertyValue("uid") as string | null
+		if (!uid) continue
+
+		const hasRecurrenceId = vevent.getFirstPropertyValue("recurrence-id") !== null
+		let group = byUid.get(uid)
+		if (!group) {
+			group = { master: null, exceptions: [] }
+			byUid.set(uid, group)
+		}
+
+		if (hasRecurrenceId) {
+			group.exceptions.push(vevent)
+		} else {
+			group.master = vevent
+		}
+	}
+
+	const results: CalDavEventData[] = []
+	const rangeStart = ICAL.Time.fromJSDate(timeRange.start, true)
+	const rangeEnd = ICAL.Time.fromJSDate(timeRange.end, true)
+
+	for (const group of byUid.values()) {
+		if (!group.master) {
+			// Orphan exceptions — parse them directly if they fall in range
+			for (const exc of group.exceptions) {
+				const parsed = parseVEvent(exc, calendarName)
+				if (overlapsRange(parsed, timeRange)) {
+					results.push(parsed)
+				}
+			}
+			continue
+		}
+
+		const masterEvent = new ICAL.Event(group.master)
+
+		// Register exceptions so getOccurrenceDetails resolves them
+		for (const exc of group.exceptions) {
+			masterEvent.relateException(exc)
+		}
+
+		if (!masterEvent.isRecurring()) {
+			const parsed = parseVEvent(group.master, calendarName)
+			if (overlapsRange(parsed, timeRange)) {
+				results.push(parsed)
+			}
+			// Also include standalone exceptions for non-recurring events
+			for (const exc of group.exceptions) {
+				const parsedExc = parseVEvent(exc, calendarName)
+				if (overlapsRange(parsedExc, timeRange)) {
+					results.push(parsedExc)
+				}
+			}
+			continue
+		}
+
+		// Expand recurring event occurrences within the time range.
+		// The iterator must start from DTSTART (not rangeStart) because
+		// ical.js needs to walk the recurrence rule grid from the original
+		// anchor. We cap iterations to avoid runaway expansion on
+		// pathological rules.
+		const iter = masterEvent.iterator()
+		let next: InstanceType<typeof ICAL.Time> | null = iter.next()
+		let iterations = 0
+
+		while (next) {
+			if (++iterations > MAX_RECURRENCE_ITERATIONS) {
+				console.warn(
+					`[aris.caldav] Recurrence expansion for "${masterEvent.uid}" hit iteration limit (${MAX_RECURRENCE_ITERATIONS}), stopping`,
+				)
+				break
+			}
+
+			// Stop once we're past the range end
+			if (next.compare(rangeEnd) >= 0) break
+
+			const details = masterEvent.getOccurrenceDetails(next)
+			const occEnd = details.endDate
+
+			// Skip occurrences that end before the range starts
+			if (occEnd.compare(rangeStart) <= 0) {
+				next = iter.next()
+				continue
+			}
+
+			const occEvent = details.item
+			const occComponent = occEvent.component
+
+			const parsed = parseVEventWithDates(
+				occComponent,
+				calendarName,
+				details.startDate.toJSDate(),
+				details.endDate.toJSDate(),
+				details.recurrenceId ? details.recurrenceId.toString() : null,
+			)
+			results.push(parsed)
+
+			next = iter.next()
+		}
+	}
+
+	return results
+}
+
+function overlapsRange(event: CalDavEventData, range: ICalTimeRange): boolean {
+	return event.startDate < range.end && event.endDate > range.start
+}
+
+/**
+ * Parse a VEVENT component, overriding start/end/recurrenceId with
+ * values from recurrence expansion.
+ */
+function parseVEventWithDates(
+	vevent: InstanceType<typeof ICAL.Component>,
+	calendarName: string | null,
+	startDate: Date,
+	endDate: Date,
+	recurrenceId: string | null,
+): CalDavEventData {
+	const event = new ICAL.Event(vevent)
+
+	return {
+		uid: event.uid ?? "",
+		title: event.summary ?? "",
+		startDate,
+		endDate,
+		isAllDay: event.startDate?.isDate ?? false,
+		location: event.location ?? null,
+		description: event.description ?? null,
+		calendarName,
+		status: parseStatus(asStringOrNull(vevent.getFirstPropertyValue("status"))),
+		url: asStringOrNull(vevent.getFirstPropertyValue("url")),
+		organizer: parseOrganizer(asStringOrNull(event.organizer), vevent),
+		attendees: parseAttendees(Array.isArray(event.attendees) ? event.attendees : []),
+		alarms: parseAlarms(vevent),
+		recurrenceId,
+	}
 }
 
 function parseVEvent(

packages/aris-source-caldav/src/index.ts

@@ -1,6 +1,6 @@
 export { CalDavCalendarKey, type CalendarContext } from "./calendar-context.ts"
 export { CalDavSource, type CalDavSourceOptions } from "./caldav-source.ts"
-export { parseICalEvents } from "./ical-parser.ts"
+export { parseICalEvents, type ICalTimeRange } from "./ical-parser.ts"
 export {
 	AttendeeRole,
 	AttendeeStatus,

packages/aris-source-google-calendar/src/calendar-context.ts

@@ -10,4 +10,4 @@ export interface NextEvent {
 	location: string | null
 }
 
-export const NextEventKey: ContextKey<NextEvent> = contextKey("nextEvent")
+export const NextEventKey: ContextKey<NextEvent> = contextKey("aris.google-calendar", "nextEvent")

packages/aris-source-google-calendar/src/google-calendar-source.test.ts

@@ -1,10 +1,10 @@
-import { TimeRelevance, contextValue, type Context } from "@aris/core"
+import { Context, TimeRelevance } from "@aris/core"
 import { describe, expect, test } from "bun:test"
 
 import type { ApiCalendarEvent, GoogleCalendarClient, ListEventsOptions } from "./types"
 
 import fixture from "../fixtures/events.json"
-import { NextEventKey } from "./calendar-context"
+import { NextEventKey, type NextEvent } from "./calendar-context"
 import { CalendarFeedItemType } from "./feed-items"
 import { GoogleCalendarSource } from "./google-calendar-source"
 
@@ -38,7 +38,7 @@ function defaultMockClient(): GoogleCalendarClient {
 }
 
 function createContext(time?: Date): Context {
-	return { time: time ?? NOW }
+	return new Context(time ?? NOW)
 }
 
 describe("GoogleCalendarSource", () => {
@@ -229,15 +229,16 @@ describe("GoogleCalendarSource", () => {
 
 		test("returns next upcoming timed event (not ongoing)", async () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
-			const result = await source.fetchContext(createContext())
+			const entries = await source.fetchContext(createContext())
 
-			expect(result).not.toBeNull()
+			expect(entries).not.toBeNull()
-			const nextEvent = contextValue(result! as Context, NextEventKey)
+			expect(entries).toHaveLength(1)
-			expect(nextEvent).toBeDefined()
+			const [key, nextEvent] = entries![0]! as [typeof NextEventKey, NextEvent]
+			expect(key).toEqual(NextEventKey)
 			// evt-soon starts at 10:10, which is the nearest future timed event
-			expect(nextEvent!.title).toBe("1:1 with Manager")
+			expect(nextEvent.title).toBe("1:1 with Manager")
-			expect(nextEvent!.minutesUntilStart).toBe(10)
+			expect(nextEvent.minutesUntilStart).toBe(10)
-			expect(nextEvent!.location).toBeNull()
+			expect(nextEvent.location).toBeNull()
 		})
 
 		test("includes location when available", async () => {
@@ -255,12 +256,11 @@ describe("GoogleCalendarSource", () => {
 			const source = new GoogleCalendarSource({
 				client: createMockClient({ primary: events }),
 			})
-			const result = await source.fetchContext(createContext())
+			const entries = await source.fetchContext(createContext())
 
-			expect(result).not.toBeNull()
+			expect(entries).not.toBeNull()
-			const nextEvent = contextValue(result! as Context, NextEventKey)
+			const [, nextEvent] = entries![0]! as [typeof NextEventKey, NextEvent]
-			expect(nextEvent).toBeDefined()
+			expect(nextEvent.location).toBe("123 Main St")
-			expect(nextEvent!.location).toBe("123 Main St")
 		})
 
 		test("skips ongoing events for next-event context", async () => {

packages/aris-source-google-calendar/src/google-calendar-source.ts

@@ -1,6 +1,6 @@
-import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { TimeRelevance, UnknownActionError } from "@aris/core"
+import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
 
 import type {
 	ApiCalendarEvent,
@@ -58,7 +58,7 @@ const URGENCY_ALL_DAY = 0.4
  *   .register(calendarSource)
  *
  * // Access next-event context in downstream sources
- * const next = contextValue(context, NextEventKey)
+ * const next = context.get(NextEventKey)
  * if (next && next.minutesUntilStart < 15) {
  *   // remind user
  * }
@@ -85,7 +85,7 @@ export class GoogleCalendarSource implements FeedSource<CalendarFeedItem> {
 		throw new UnknownActionError(actionId)
 	}
 
-	async fetchContext(context: Context): Promise<Partial<Context> | null> {
+	async fetchContext(context: Context): Promise<readonly ContextEntry[] | null> {
 		const events = await this.fetchAllEvents(context.time)
 
 		const now = context.time.getTime()
@@ -105,7 +105,7 @@ export class GoogleCalendarSource implements FeedSource<CalendarFeedItem> {
 			location: nextTimedEvent.location,
 		}
 
-		return { [NextEventKey]: nextEvent }
+		return [[NextEventKey, nextEvent]]
 	}
 
 	async fetchItems(context: Context): Promise<CalendarFeedItem[]> {

packages/aris-source-location/src/location-source.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, mock, test } from "bun:test"
 
-import { LocationKey, LocationSource, type Location } from "./location-source.ts"
+import type { Location } from "./types.ts"
+
+import { LocationKey, LocationSource } from "./location-source.ts"
 
 function createLocation(overrides: Partial<Location> = {}): Location {
 	return {
@@ -39,8 +41,8 @@ describe("LocationSource", () => {
 			const location = createLocation()
 			source.pushLocation(location)
 
-			const context = await source.fetchContext()
+			const entries = await source.fetchContext()
-			expect(context).toEqual({ [LocationKey]: location })
+			expect(entries).toEqual([[LocationKey, location]])
 		})
 	})
 
@@ -65,7 +67,7 @@ describe("LocationSource", () => {
 			source.pushLocation(location)
 
 			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith({ [LocationKey]: location })
+			expect(listener).toHaveBeenCalledWith([[LocationKey, location]])
 		})
 	})
 

packages/aris-source-location/src/location-source.ts

@@ -1,11 +1,11 @@
-import type { ActionDefinition, Context, FeedSource } from "@aris/core"
+import type { ActionDefinition, ContextEntry, FeedSource } from "@aris/core"
 
-import { UnknownActionError, contextKey, type ContextKey } from "@aris/core"
+import { Context, UnknownActionError, contextKey, type ContextKey } from "@aris/core"
 import { type } from "arktype"
 
 import { Location, type LocationSourceOptions } from "./types.ts"
 
-export const LocationKey: ContextKey<Location> = contextKey("location")
+export const LocationKey: ContextKey<Location> = contextKey("aris.location", "location")
 
 /**
  * A FeedSource that provides location context.
@@ -20,7 +20,7 @@ export class LocationSource implements FeedSource {
 
 	private readonly historySize: number
 	private locations: Location[] = []
-	private listeners = new Set<(update: Partial<Context>) => void>()
+	private listeners = new Set<(entries: readonly ContextEntry[]) => void>()
 
 	constructor(options: LocationSourceOptions = {}) {
 		this.historySize = options.historySize ?? 1
@@ -59,8 +59,9 @@ export class LocationSource implements FeedSource {
 		if (this.locations.length > this.historySize) {
 			this.locations.shift()
 		}
+		const entries: readonly ContextEntry[] = [[LocationKey, location]]
 		this.listeners.forEach((listener) => {
-			listener({ [LocationKey]: location })
+			listener(entries)
 		})
 	}
 
@@ -78,16 +79,16 @@ export class LocationSource implements FeedSource {
 		return this.locations
 	}
 
-	onContextUpdate(callback: (update: Partial<Context>) => void): () => void {
+	onContextUpdate(callback: (entries: readonly ContextEntry[]) => void): () => void {
 		this.listeners.add(callback)
 		return () => {
 			this.listeners.delete(callback)
 		}
 	}
 
-	async fetchContext(): Promise<Partial<Context> | null> {
+	async fetchContext(): Promise<readonly ContextEntry[] | null> {
 		if (this.lastLocation) {
-			return { [LocationKey]: this.lastLocation }
+			return [[LocationKey, this.lastLocation]]
 		}
 		return null
 	}

packages/aris-source-tfl/src/tfl-source.test.ts

@@ -1,5 +1,4 @@
-import type { Context } from "@aris/core"
+import { Context } from "@aris/core"
-
 import { LocationKey, type Location } from "@aris/source-location"
 import { describe, expect, test } from "bun:test"
 
@@ -81,9 +80,9 @@ class FixtureTflApi implements ITflApi {
 }
 
 function createContext(location?: Location): Context {
-	const ctx: Context = { time: new Date("2026-01-15T12:00:00Z") }
+	const ctx = new Context(new Date("2026-01-15T12:00:00Z"))
 	if (location) {
-		ctx[LocationKey] = location
+		ctx.set([[LocationKey, location]])
 	}
 	return ctx
 }

packages/aris-source-tfl/src/tfl-source.ts

@@ -1,6 +1,6 @@
-import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { TimeRelevance, UnknownActionError, contextValue } from "@aris/core"
+import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
 import { LocationKey } from "@aris/source-location"
 import { type } from "arktype"
 
@@ -112,7 +112,7 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 		}
 	}
 
-	async fetchContext(): Promise<null> {
+	async fetchContext(): Promise<readonly ContextEntry[] | null> {
 		return null
 	}
 
@@ -129,7 +129,7 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 			this.client.fetchStations(),
 		])
 
-		const location = contextValue(context, LocationKey)
+		const location = context.get(LocationKey)
 
 		const items: TflAlertFeedItem[] = statuses.map((status) => {
 			const closestStationDistance = location

packages/aris-source-weatherkit/scripts/query.ts

@@ -0,0 +1,181 @@
+#!/usr/bin/env bun
+
+/**
+ * Interactive CLI script to query WeatherKit directly.
+ * Prompts for credentials, coordinates, and optional settings,
+ * then prints the raw API response and processed feed items.
+ * Caches credentials locally and writes response JSON to a file.
+ *
+ * Usage: bun packages/aris-source-weatherkit/scripts/query.ts
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { createInterface } from "node:readline/promises"
+
+import { Context } from "@aris/core"
+import { LocationKey } from "@aris/source-location"
+
+import { DefaultWeatherKitClient } from "../src/weatherkit"
+import { WeatherSource, Units } from "../src/weather-source"
+
+const SCRIPT_DIR = import.meta.dirname
+const CACHE_DIR = join(SCRIPT_DIR, ".cache")
+const CREDS_PATH = join(CACHE_DIR, "credentials.json")
+
+interface CachedCredentials {
+	teamId: string
+	serviceId: string
+	keyId: string
+	privateKey: string
+	lat?: number
+	lng?: number
+}
+
+function loadCachedCredentials(): CachedCredentials | null {
+	if (!existsSync(CREDS_PATH)) return null
+	try {
+		return JSON.parse(readFileSync(CREDS_PATH, "utf-8")) as CachedCredentials
+	} catch {
+		return null
+	}
+}
+
+function saveCachedCredentials(creds: CachedCredentials): void {
+	mkdirSync(CACHE_DIR, { recursive: true })
+	writeFileSync(CREDS_PATH, JSON.stringify(creds))
+}
+
+const rl = createInterface({ input: process.stdin, output: process.stdout })
+
+async function prompt(question: string, defaultValue?: string): Promise<string> {
+	const suffix = defaultValue ? ` [${defaultValue}]` : ""
+	const answer = await rl.question(`${question}${suffix}: `)
+	return answer.trim() || defaultValue || ""
+}
+
+async function main(): Promise<void> {
+	console.log("=== WeatherKit Query Tool ===\n")
+
+	const cached = loadCachedCredentials()
+
+	let teamId: string
+	let serviceId: string
+	let keyId: string
+	let privateKey: string
+
+	if (cached) {
+		console.log(`Using cached credentials from ${CREDS_PATH}`)
+		console.log(`  Team ID:    ${cached.teamId}`)
+		console.log(`  Service ID: ${cached.serviceId}`)
+		console.log(`  Key ID:     ${cached.keyId}\n`)
+
+		const useCached = await prompt("Use cached credentials? (y/n)", "y")
+		if (useCached.toLowerCase() === "y") {
+			teamId = cached.teamId
+			serviceId = cached.serviceId
+			keyId = cached.keyId
+			privateKey = cached.privateKey
+		} else {
+			;({ teamId, serviceId, keyId, privateKey } = await promptCredentials())
+		}
+	} else {
+		console.log(`Credentials will be cached to ${CREDS_PATH}\n`)
+		;({ teamId, serviceId, keyId, privateKey } = await promptCredentials())
+	}
+
+	// Location
+	const defaultLat = cached?.lat?.toString() ?? "37.7749"
+	const defaultLng = cached?.lng?.toString() ?? "-122.4194"
+	const lat = parseFloat(await prompt("Latitude", defaultLat))
+	const lng = parseFloat(await prompt("Longitude", defaultLng))
+
+	if (Number.isNaN(lat) || Number.isNaN(lng)) {
+		console.error("Invalid coordinates")
+		process.exit(1)
+	}
+
+	const credentials = { privateKey, keyId, teamId, serviceId }
+	saveCachedCredentials({ ...credentials, lat, lng })
+
+	// Options
+	const unitsInput = await prompt("Units (metric/imperial)", "metric")
+	const units = unitsInput === "imperial" ? Units.imperial : Units.metric
+
+	// Raw API query
+	console.log("\n--- Raw WeatherKit Response ---\n")
+	const client = new DefaultWeatherKitClient(credentials)
+	const raw = await client.fetch({ lat, lng })
+	console.log(JSON.stringify(raw, null, 2))
+
+	// Write JSON to file
+	const outPath = join(CACHE_DIR, "response.json")
+	writeFileSync(outPath, JSON.stringify(raw))
+	console.log(`\nResponse written to ${outPath}`)
+
+	// Processed feed items via WeatherSource
+	console.log("\n--- Processed Feed Items ---\n")
+	const source = new WeatherSource({ client, units })
+	const context = new Context()
+	context.set([[LocationKey, { lat, lng, accuracy: 10, timestamp: new Date() }]])
+
+	const items = await source.fetchItems(context)
+	for (const item of items) {
+		console.log(`[${item.type}] ${item.id}`)
+		console.log(`  signals: ${JSON.stringify(item.signals)}`)
+		if (item.slots) {
+			console.log(`  slots:`)
+			for (const [name, slot] of Object.entries(item.slots)) {
+				console.log(`    ${name}: "${slot.description}" -> ${slot.content ?? "(unfilled)"}`)
+			}
+		}
+		console.log(`  data: ${JSON.stringify(item.data, null, 4)}`)
+		console.log()
+	}
+
+	const feedPath = join(CACHE_DIR, "feed-items.json")
+	writeFileSync(feedPath, JSON.stringify(items, null, 2))
+	console.log(`Feed items written to ${feedPath}`)
+	console.log(`Total: ${items.length} items`)
+	rl.close()
+}
+
+async function promptCredentials(): Promise<CachedCredentials> {
+	const teamId = await prompt("Apple Team ID")
+	if (!teamId) {
+		console.error("Team ID is required")
+		process.exit(1)
+	}
+
+	const serviceId = await prompt("Service ID")
+	if (!serviceId) {
+		console.error("Service ID is required")
+		process.exit(1)
+	}
+
+	const keyId = await prompt("Key ID")
+	if (!keyId) {
+		console.error("Key ID is required")
+		process.exit(1)
+	}
+
+	console.log("\nPaste your private key (PEM format). Enter an empty line when done:")
+	const keyLines: string[] = []
+	for await (const line of rl) {
+		if (line.trim() === "") break
+		keyLines.push(line)
+	}
+	const privateKey = keyLines.join("\n")
+	if (!privateKey) {
+		console.error("Private key is required")
+		process.exit(1)
+	}
+
+	return { teamId, serviceId, keyId, privateKey }
+}
+
+main().catch((err) => {
+	console.error("Error:", err)
+	rl.close()
+	process.exit(1)
+})

packages/aris-source-weatherkit/src/prompts/current-weather-insight.txt

@@ -0,0 +1,7 @@
+Max 12 words. Plain language, no hedging. Now + what's next.
+
+Examples:
+- "Clear tonight, warming up. Rain by Saturday."
+- "Clearing soon with strong winds overnight. Light rain Thursday."
+- "Sunny all day. Grab sunscreen."
+- "Cloudy tonight, warming to 15°. Rain Monday."

packages/aris-source-weatherkit/src/weather-context.ts

@@ -24,4 +24,4 @@ export interface Weather {
 	daylight: boolean
 }
 
-export const WeatherKey: ContextKey<Weather> = contextKey("weather")
+export const WeatherKey: ContextKey<Weather> = contextKey("aris.weather", "weather")

packages/aris-source-weatherkit/src/weather-source.test.ts

@@ -1,4 +1,6 @@
-import { contextValue, type Context } from "@aris/core"
+import type { FeedSource } from "@aris/core"
+
+import { Context } from "@aris/core"
 import { LocationKey } from "@aris/source-location"
 import { describe, expect, test } from "bun:test"
 
@@ -6,7 +8,7 @@ import type { WeatherKitClient, WeatherKitResponse } from "./weatherkit"
 
 import fixture from "../fixtures/san-francisco.json"
 import { WeatherFeedItemType } from "./feed-items"
-import { WeatherKey } from "./weather-context"
+import { WeatherKey, type Weather } from "./weather-context"
 import { WeatherSource, Units } from "./weather-source"
 
 const mockCredentials = {
@@ -23,9 +25,9 @@ function createMockClient(response: WeatherKitResponse): WeatherKitClient {
 }
 
 function createMockContext(location?: { lat: number; lng: number }): Context {
-	const ctx: Context = { time: new Date("2026-01-17T00:00:00Z") }
+	const ctx = new Context(new Date("2026-01-17T00:00:00Z"))
 	if (location) {
-		ctx[LocationKey] = { ...location, accuracy: 10, timestamp: new Date() }
+		ctx.set([[LocationKey, { ...location, accuracy: 10, timestamp: new Date() }]])
 	}
 	return ctx
 }
@@ -63,18 +65,19 @@ describe("WeatherSource", () => {
 			const source = new WeatherSource({ client: mockClient })
 			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
 
-			const result = await source.fetchContext(context)
+			const entries = await source.fetchContext(context)
-			expect(result).not.toBeNull()
+			expect(entries).not.toBeNull()
-			const weather = contextValue(result! as Context, WeatherKey)
+			expect(entries).toHaveLength(1)
 
-			expect(weather).toBeDefined()
+			const [key, weather] = entries![0]! as [typeof WeatherKey, Weather]
-			expect(typeof weather!.temperature).toBe("number")
+			expect(key).toEqual(WeatherKey)
-			expect(typeof weather!.temperatureApparent).toBe("number")
+			expect(typeof weather.temperature).toBe("number")
-			expect(typeof weather!.condition).toBe("string")
+			expect(typeof weather.temperatureApparent).toBe("number")
-			expect(typeof weather!.humidity).toBe("number")
+			expect(typeof weather.condition).toBe("string")
-			expect(typeof weather!.uvIndex).toBe("number")
+			expect(typeof weather.humidity).toBe("number")
-			expect(typeof weather!.windSpeed).toBe("number")
+			expect(typeof weather.uvIndex).toBe("number")
-			expect(typeof weather!.daylight).toBe("boolean")
+			expect(typeof weather.windSpeed).toBe("number")
+			expect(typeof weather.daylight).toBe("boolean")
 		})
 
 		test("converts temperature to imperial", async () => {
@@ -84,12 +87,12 @@ describe("WeatherSource", () => {
 			})
 			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
 
-			const result = await source.fetchContext(context)
+			const entries = await source.fetchContext(context)
-			expect(result).not.toBeNull()
+			expect(entries).not.toBeNull()
-			const weather = contextValue(result! as Context, WeatherKey)
 
+			const [, weather] = entries![0]! as [typeof WeatherKey, Weather]
 			// Fixture has temperature around 10°C, imperial should be around 50°F
-			expect(weather!.temperature).toBeGreaterThan(40)
+			expect(weather.temperature).toBeGreaterThan(40)
 		})
 	})
 
@@ -173,16 +176,44 @@ describe("WeatherSource", () => {
 
 			expect(uniqueIds.size).toBe(ids.length)
 		})
+
+		test("current weather item has insight slot", async () => {
+			const source = new WeatherSource({ client: mockClient })
+			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+
+			const items = await source.fetchItems(context)
+			const currentItem = items.find((i) => i.type === WeatherFeedItemType.Current)
+
+			expect(currentItem).toBeDefined()
+			expect(currentItem!.slots).toBeDefined()
+			expect(currentItem!.slots!.insight).toBeDefined()
+			expect(currentItem!.slots!.insight!.description).toBeString()
+			expect(currentItem!.slots!.insight!.description.length).toBeGreaterThan(0)
+			expect(currentItem!.slots!.insight!.content).toBeNull()
+		})
+
+		test("non-current items do not have slots", async () => {
+			const source = new WeatherSource({ client: mockClient })
+			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+
+			const items = await source.fetchItems(context)
+			const nonCurrentItems = items.filter((i) => i.type !== WeatherFeedItemType.Current)
+
+			expect(nonCurrentItems.length).toBeGreaterThan(0)
+			for (const item of nonCurrentItems) {
+				expect(item.slots).toBeUndefined()
+			}
+		})
 	})
 
 	describe("no reactive methods", () => {
 		test("does not implement onContextUpdate", () => {
-			const source = new WeatherSource({ credentials: mockCredentials })
+			const source: FeedSource = new WeatherSource({ credentials: mockCredentials })
 			expect(source.onContextUpdate).toBeUndefined()
 		})
 
 		test("does not implement onItemsUpdate", () => {
-			const source = new WeatherSource({ credentials: mockCredentials })
+			const source: FeedSource = new WeatherSource({ credentials: mockCredentials })
 			expect(source.onItemsUpdate).toBeUndefined()
 		})
 	})

packages/aris-source-weatherkit/src/weather-source.ts

@@ -1,9 +1,10 @@
-import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { TimeRelevance, UnknownActionError, contextValue } from "@aris/core"
+import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
 import { LocationKey } from "@aris/source-location"
 
 import { WeatherFeedItemType, type WeatherFeedItem } from "./feed-items"
+import currentWeatherInsightPrompt from "./prompts/current-weather-insight.txt"
 import { WeatherKey, type Weather } from "./weather-context"
 import {
 	DefaultWeatherKitClient,
@@ -86,7 +87,7 @@ const MODERATE_CONDITIONS = new Set<ConditionCode>([
  * })
  *
  * // Access weather context in downstream sources
- * const weather = contextValue(context, WeatherKey)
+ * const weather = context.get(WeatherKey)
  * if (weather?.condition === "Rain") {
  *   // suggest umbrella
  * }
@@ -119,8 +120,8 @@ export class WeatherSource implements FeedSource<WeatherFeedItem> {
 		throw new UnknownActionError(actionId)
 	}
 
-	async fetchContext(context: Context): Promise<Partial<Context> | null> {
+	async fetchContext(context: Context): Promise<readonly ContextEntry[] | null> {
-		const location = contextValue(context, LocationKey)
+		const location = context.get(LocationKey)
 		if (!location) {
 			return null
 		}
@@ -147,11 +148,11 @@ export class WeatherSource implements FeedSource<WeatherFeedItem> {
 			daylight: response.currentWeather.daylight,
 		}
 
-		return { [WeatherKey]: weather }
+		return [[WeatherKey, weather]]
 	}
 
 	async fetchItems(context: Context): Promise<WeatherFeedItem[]> {
-		const location = contextValue(context, LocationKey)
+		const location = context.get(LocationKey)
 		if (!location) {
 			return []
 		}
@@ -309,6 +310,12 @@ function createCurrentWeatherFeedItem(
 			windSpeed: convertSpeed(current.windSpeed, units),
 		},
 		signals,
+		slots: {
+			insight: {
+				description: currentWeatherInsightPrompt,
+				content: null,
+			},
+		},
 	}
 }