feat: add GPG commit signing skill

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

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

@@ -1,4 +1,4 @@
-import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, 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<readonly ContextEntry[] | null> {
+		async fetchContext(): Promise<Partial<Context> | null> {
 			return null
 		},
 		async fetchItems() {

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

@@ -1,4 +1,4 @@
-import type { ActionDefinition, ContextEntry, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedSource } from "@aris/core"
 
 import { LocationSource } from "@aris/source-location"
 import { describe, expect, test } from "bun:test"
@@ -14,7 +14,7 @@ function createStubSource(id: string): FeedSource {
 		async executeAction(): Promise<unknown> {
 			return undefined
 		},
-		async fetchContext(): Promise<readonly ContextEntry[] | null> {
+		async fetchContext(): Promise<Partial<Context> | null> {
 			return null
 		},
 		async fetchItems() {

bun.lock

@@ -89,17 +89,6 @@
         "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",
@@ -155,8 +144,6 @@
 
     "@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"],

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

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

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

@@ -1,184 +0,0 @@
-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,131 +1,46 @@
 /**
- * Tuple-keyed context system inspired by React Query's query keys.
+ * Branded type for type-safe context keys.
  *
- * Context keys are arrays that form a hierarchy. Sources write to specific
- * keys (e.g., ["aris.google-calendar", "nextEvent", { account: "work" }])
- * and consumers can query by exact match or prefix match to get all values
- * of a given type across source instances.
+ * Each package defines its own keys with associated value types:
+ * ```ts
+ * const LocationKey: ContextKey<Location> = contextKey("location")
+ * ```
  */
-
-// -- Key types --
-
-/** A single segment of a context key: string, number, or a record of primitives. */
-export type ContextKeyPart = string | number | Record<string, unknown>
-
-/** A context key is a readonly tuple of parts, branded with the value type. */
-export type ContextKey<T> = readonly ContextKeyPart[] & { __contextValue?: T }
-
-/** Creates a typed context key. */
-export function contextKey<T>(...parts: ContextKeyPart[]): ContextKey<T> {
-	return parts as ContextKey<T>
-}
-
-// -- Serialization --
+export type ContextKey<T> = string & { __contextValue?: T }
 
 /**
- * Deterministic serialization of a context key for use as a Map key.
- * Object parts have their keys sorted for stable comparison.
- */
-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
-	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.
+ * Creates a typed context key.
  *
  * @example
  * ```ts
-	 * // Get all "nextEvent" values across calendar source instances
-	 * const events = context.find(contextKey("nextEvent"))
+ * interface Location { lat: number; lng: number; accuracy: number }
+ * const LocationKey: ContextKey<Location> = contextKey("location")
  * ```
  */
-	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
-	}
+export function contextKey<T>(key: string): ContextKey<T> {
+	return key as ContextKey<T>
+}
+
+/**
+ * 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.
+ * Always includes `time`. Other keys are added by context providers.
+ */
+export interface Context {
+	time: Date
+	[key: string]: unknown
 }

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 = context.get(LocationKey)
+ *     const location = contextValue(context, LocationKey)
  *     if (!location) return []
  *     const data = await fetchWeather(location)
  *     return [{

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

@@ -1,9 +1,8 @@
-import type { ContextEntry } from "./context"
+import type { Context } 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 {
@@ -41,7 +40,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()
@@ -60,7 +59,7 @@ export class FeedController<TItems extends FeedItem = never> {
 	private stopped = false
 
 	constructor(config?: FeedControllerConfig) {
-		this.context = config?.initialContext ?? new Context()
+		this.context = config?.initialContext ?? { time: new Date() }
 		this.debounceMs = config?.debounceMs ?? DEFAULT_DEBOUNCE_MS
 		this.timeout = config?.timeout
 	}
@@ -95,10 +94,9 @@ export class FeedController<TItems extends FeedItem = never> {
 		}
 	}
 
-	/** Merges entries into context and schedules a debounced reconcile. */
-	pushContextUpdate(entries: readonly ContextEntry[]): void {
-		this.context.time = new Date()
-		this.context.set(entries)
+	/** Merges update into context and schedules a debounced reconcile. */
+	pushContextUpdate(update: Partial<Context>): void {
+		this.context = { ...this.context, ...update, time: new Date() }
 		this.scheduleReconcile()
 	}
 

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

@@ -1,9 +1,9 @@
 import { describe, expect, test } from "bun:test"
 
-import type { ActionDefinition, ContextEntry, ContextKey, FeedItem, FeedSource } from "./index"
+import type { ActionDefinition, Context, ContextKey, FeedItem, FeedSource } from "./index"
 
 import { FeedEngine } from "./feed-engine"
-import { Context, TimeRelevance, UnknownActionError, contextKey } from "./index"
+import { TimeRelevance, UnknownActionError, contextKey, contextValue } from "./index"
 
 // No-op action methods for test sources
 const noActions = {
@@ -48,7 +48,7 @@ interface SimulatedLocationSource extends FeedSource {
 }
 
 function createLocationSource(): SimulatedLocationSource {
-	let callback: ((entries: readonly ContextEntry[]) => void) | null = null
+	let callback: ((update: Partial<Context>) => 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 = context.get(LocationKey)
+			const location = contextValue(context, LocationKey)
 			if (!location) return null
 
 			const weather = await fetchWeather(location)
-			return [[WeatherKey, weather]]
+			return { [WeatherKey]: weather }
 		},
 
 		async fetchItems(context) {
-			const weather = context.get(WeatherKey)
+			const weather = contextValue(context, WeatherKey)
 			if (!weather) return []
 
 			return [
@@ -123,7 +123,7 @@ function createAlertSource(): FeedSource<AlertFeedItem> {
 		},
 
 		async fetchItems(context) {
-			const weather = context.get(WeatherKey)
+			const weather = contextValue(context, 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 = ctx.get(LocationKey)
+					const loc = contextValue(ctx, 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(context.get(LocationKey)).toEqual({
+			expect(contextValue(context, LocationKey)).toEqual({
 				lat: 51.5,
 				lng: -0.1,
 			})
-			expect(context.get(WeatherKey)).toEqual({
+			expect(contextValue(context, WeatherKey)).toEqual({
 				temperature: 20,
 				condition: "sunny",
 			})
@@ -361,7 +361,7 @@ describe("FeedEngine", () => {
 
 			const { context, items } = await engine.refresh()
 
-			expect(context.get(WeatherKey)).toBeUndefined()
+			expect(contextValue(context, WeatherKey)).toBeUndefined()
 			expect(items).toHaveLength(0)
 		})
 
@@ -459,7 +459,7 @@ describe("FeedEngine", () => {
 			await engine.refresh()
 
 			const context = engine.currentContext()
-			expect(context.get(LocationKey)).toEqual({
+			expect(contextValue(context, LocationKey)).toEqual({
 				lat: 51.5,
 				lng: -0.1,
 			})
@@ -734,7 +734,7 @@ describe("FeedEngine", () => {
 		})
 
 		test("reactive item update refreshes cache", async () => {
-			let itemUpdateCallback: ((items: FeedItem[]) => void) | null = null
+			let itemUpdateCallback: (() => 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 = ctx.get(LocationKey)
+					const loc = contextValue(ctx, LocationKey)
 					if (!loc) return null
-					return [[WeatherKey, { temperature: 20, condition: "sunny" }]]
+					return { [WeatherKey]: { temperature: 20, condition: "sunny" } }
 				},
 				async fetchItems(ctx) {
-					const weather = ctx.get(WeatherKey)
+					const weather = contextValue(ctx, WeatherKey)
 					if (!weather) return []
 					return [
 						{

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

@@ -1,11 +1,9 @@
 import type { ActionDefinition } from "./action"
-import type { ContextEntry } from "./context"
+import type { Context } 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
@@ -67,7 +65,7 @@ interface SourceGraph {
 export class FeedEngine<TItems extends FeedItem = FeedItem> {
 	private sources = new Map<string, FeedSource>()
 	private graph: SourceGraph | null = null
-	private context: Context = new Context()
+	private context: Context = { time: new Date() }
 	private subscribers = new Set<FeedSubscriber<TItems>>()
 	private cleanups: Array<() => void> = []
 	private started = false
@@ -140,14 +138,14 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 		const errors: SourceError[] = []
 
 		// Reset context with fresh time
-		const context = new Context()
+		let context: Context = { time: new Date() }
 
 		// Run fetchContext in topological order
 		for (const source of graph.sorted) {
 			try {
-				const entries = await source.fetchContext(context)
-				if (entries) {
-					context.set(entries)
+				const update = await source.fetchContext(context)
+				if (update) {
+					context = { ...context, ...update }
 				}
 			} catch (err) {
 				errors.push({
@@ -179,7 +177,7 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 			items: processedItems,
 			groupedItems,
 			errors: postProcessorErrors,
-		} = await this.applyPostProcessors(items as TItems[], context, errors)
+		} = await this.applyPostProcessors(items as TItems[], errors)
 
 		const result: FeedResult<TItems> = {
 			context,
@@ -215,8 +213,8 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 		for (const source of graph.sorted) {
 			if (source.onContextUpdate) {
 				const cleanup = source.onContextUpdate(
-					(entries) => {
-						this.handleContextUpdate(source.id, entries)
+					(update) => {
+						this.handleContextUpdate(source.id, update)
 					},
 					() => this.context,
 				)
@@ -296,18 +294,16 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 
 	private async applyPostProcessors(
 		items: TItems[],
-		context: Context,
 		errors: SourceError[],
 	): Promise<{ items: TItems[]; groupedItems: ItemGroup[]; errors: SourceError[] }> {
 		let currentItems = items
 		const allGroupedItems: ItemGroup[] = []
 		const allErrors = [...errors]
-		const boostScores = new Map<string, number>()
 
 		for (const processor of this.postProcessors) {
 			const snapshot = currentItems
 			try {
-				const enhancement = await processor(currentItems, context)
+				const enhancement = await processor(currentItems)
 
 				if (enhancement.additionalItems?.length) {
 					// Post-processors operate on FeedItem[] without knowledge of TItems.
@@ -325,12 +321,6 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 				if (enhancement.groupedItems?.length) {
 					allGroupedItems.push(...enhancement.groupedItems)
 				}
-
-				if (enhancement.boost) {
-					for (const [id, score] of Object.entries(enhancement.boost)) {
-						boostScores.set(id, (boostScores.get(id) ?? 0) + score)
-					}
-				}
 			} catch (err) {
 				const sourceId = processor.name || "anonymous"
 				allErrors.push({
@@ -341,12 +331,6 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 			}
 		}
 
-		// Apply boost reordering: positive-boost first (desc), then zero, then negative (desc).
-		// Stable sort within each tier preserves original relative order.
-		if (boostScores.size > 0) {
-			currentItems = applyBoostOrder(currentItems, boostScores)
-		}
-
 		// Remove stale item IDs from groups and drop empty groups
 		const itemIds = new Set(currentItems.map((item) => item.id))
 		const validGroups = allGroupedItems.reduce<ItemGroup[]>((acc, group) => {
@@ -367,9 +351,8 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 		return this.graph
 	}
 
-	private handleContextUpdate(sourceId: string, entries: readonly ContextEntry[]): void {
-		this.context.time = new Date()
-		this.context.set(entries)
+	private handleContextUpdate(sourceId: string, update: Partial<Context>): void {
+		this.context = { ...this.context, ...update, time: new Date() }
 
 		// Re-run dependents and notify
 		this.refreshDependents(sourceId)
@@ -384,9 +367,9 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 			const source = graph.sources.get(id)
 			if (source) {
 				try {
-					const entries = await source.fetchContext(this.context)
-					if (entries) {
-						this.context.set(entries)
+					const update = await source.fetchContext(this.context)
+					if (update) {
+						this.context = { ...this.context, ...update }
 					}
 				} catch {
 					// Errors during reactive updates are logged but don't stop propagation
@@ -416,7 +399,7 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 			items: processedItems,
 			groupedItems,
 			errors: postProcessorErrors,
-		} = await this.applyPostProcessors(items as TItems[], this.context, errors)
+		} = await this.applyPostProcessors(items as TItems[], errors)
 
 		const result: FeedResult<TItems> = {
 			context: this.context,
@@ -503,47 +486,6 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 	}
 }
 
-function clamp(value: number, min: number, max: number): number {
-	return Math.min(max, Math.max(min, value))
-}
-
-function applyBoostOrder<T extends FeedItem>(items: T[], boostScores: Map<string, number>): T[] {
-	const positive: T[] = []
-	const neutral: T[] = []
-	const negative: T[] = []
-
-	for (const item of items) {
-		const raw = boostScores.get(item.id)
-		if (raw === undefined || raw === 0) {
-			neutral.push(item)
-		} else {
-			const clamped = clamp(raw, -1, 1)
-			if (clamped > 0) {
-				positive.push(item)
-			} else if (clamped < 0) {
-				negative.push(item)
-			} else {
-				neutral.push(item)
-			}
-		}
-	}
-
-	// Sort positive descending by boost, negative descending (least negative first, most negative last)
-	positive.sort((a, b) => {
-		const aScore = clamp(boostScores.get(a.id) ?? 0, -1, 1)
-		const bScore = clamp(boostScores.get(b.id) ?? 0, -1, 1)
-		return bScore - aScore
-	})
-
-	negative.sort((a, b) => {
-		const aScore = clamp(boostScores.get(a.id) ?? 0, -1, 1)
-		const bScore = clamp(boostScores.get(b.id) ?? 0, -1, 1)
-		return bScore - aScore
-	})
-
-	return [...positive, ...neutral, ...negative]
-}
-
 function buildGraph(sources: FeedSource[]): SourceGraph {
 	const byId = new Map<string, FeedSource>()
 	for (const source of sources) {

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

@@ -1,12 +1,6 @@
 import { describe, expect, mock, test } from "bun:test"
 
-import type {
-	ActionDefinition,
-	ContextEntry,
-	FeedItem,
-	FeedPostProcessor,
-	FeedSource,
-} from "./index"
+import type { ActionDefinition, FeedItem, FeedPostProcessor, FeedSource } from "./index"
 
 import { FeedEngine } from "./feed-engine"
 import { UnknownActionError } from "./index"
@@ -215,163 +209,6 @@ describe("FeedPostProcessor", () => {
 		})
 	})
 
-	// =============================================================================
-	// BOOST
-	// =============================================================================
-
-	describe("boost", () => {
-		test("positive boost moves item before non-boosted items", async () => {
-			const engine = new FeedEngine()
-				.register(createWeatherSource([weatherItem("w1", 20), weatherItem("w2", 25)]))
-				.registerPostProcessor(async () => ({ boost: { w2: 0.8 } }))
-
-			const result = await engine.refresh()
-			expect(result.items.map((i) => i.id)).toEqual(["w2", "w1"])
-		})
-
-		test("negative boost moves item after non-boosted items", async () => {
-			const engine = new FeedEngine()
-				.register(createWeatherSource([weatherItem("w1", 20), weatherItem("w2", 25)]))
-				.registerPostProcessor(async () => ({ boost: { w1: -0.5 } }))
-
-			const result = await engine.refresh()
-			expect(result.items.map((i) => i.id)).toEqual(["w2", "w1"])
-		})
-
-		test("multiple boosted items are sorted by boost descending", async () => {
-			const engine = new FeedEngine()
-				.register(
-					createWeatherSource([
-						weatherItem("w1", 20),
-						weatherItem("w2", 25),
-						weatherItem("w3", 30),
-					]),
-				)
-				.registerPostProcessor(async () => ({
-					boost: { w3: 0.3, w1: 0.9 },
-				}))
-
-			const result = await engine.refresh()
-			// w1 (0.9) first, w3 (0.3) second, w2 (no boost) last
-			expect(result.items.map((i) => i.id)).toEqual(["w1", "w3", "w2"])
-		})
-
-		test("multiple processors accumulate boost scores", async () => {
-			const engine = new FeedEngine()
-				.register(createWeatherSource([weatherItem("w1", 20), weatherItem("w2", 25)]))
-				.registerPostProcessor(async () => ({ boost: { w1: 0.3 } }))
-				.registerPostProcessor(async () => ({ boost: { w1: 0.4 } }))
-
-			const result = await engine.refresh()
-			// w1 accumulated boost = 0.7, moves before w2
-			expect(result.items.map((i) => i.id)).toEqual(["w1", "w2"])
-		})
-
-		test("accumulated boost is clamped to [-1, 1]", async () => {
-			const engine = new FeedEngine()
-				.register(
-					createWeatherSource([
-						weatherItem("w1", 20),
-						weatherItem("w2", 25),
-						weatherItem("w3", 30),
-					]),
-				)
-				.registerPostProcessor(async () => ({ boost: { w1: 0.8, w2: 0.9 } }))
-				.registerPostProcessor(async () => ({ boost: { w1: 0.8 } }))
-
-			const result = await engine.refresh()
-			// w1 accumulated = 1.6 clamped to 1, w2 = 0.9 — w1 still first
-			expect(result.items.map((i) => i.id)).toEqual(["w1", "w2", "w3"])
-		})
-
-		test("out-of-range boost values are clamped", async () => {
-			const engine = new FeedEngine()
-				.register(createWeatherSource([weatherItem("w1", 20), weatherItem("w2", 25)]))
-				.registerPostProcessor(async () => ({ boost: { w1: 5.0 } }))
-
-			const result = await engine.refresh()
-			// Clamped to 1, still boosted to front
-			expect(result.items.map((i) => i.id)).toEqual(["w1", "w2"])
-		})
-
-		test("boosting a suppressed item is a no-op", async () => {
-			const engine = new FeedEngine()
-				.register(createWeatherSource([weatherItem("w1", 20), weatherItem("w2", 25)]))
-				.registerPostProcessor(async () => ({
-					suppress: ["w1"],
-					boost: { w1: 1.0 },
-				}))
-
-			const result = await engine.refresh()
-			expect(result.items).toHaveLength(1)
-			expect(result.items[0].id).toBe("w2")
-		})
-
-		test("boosting a nonexistent item ID is a no-op", async () => {
-			const engine = new FeedEngine()
-				.register(createWeatherSource([weatherItem("w1", 20)]))
-				.registerPostProcessor(async () => ({ boost: { nonexistent: 1.0 } }))
-
-			const result = await engine.refresh()
-			expect(result.items).toHaveLength(1)
-			expect(result.items[0].id).toBe("w1")
-		})
-
-		test("items with equal boost retain original relative order", async () => {
-			const engine = new FeedEngine()
-				.register(
-					createWeatherSource([
-						weatherItem("w1", 20),
-						weatherItem("w2", 25),
-						weatherItem("w3", 30),
-					]),
-				)
-				.registerPostProcessor(async () => ({
-					boost: { w1: 0.5, w3: 0.5 },
-				}))
-
-			const result = await engine.refresh()
-			// w1 and w3 have equal boost — original order preserved: w1 before w3
-			expect(result.items.map((i) => i.id)).toEqual(["w1", "w3", "w2"])
-		})
-
-		test("negative boosts preserve relative order among demoted items", async () => {
-			const engine = new FeedEngine()
-				.register(
-					createWeatherSource([
-						weatherItem("w1", 20),
-						weatherItem("w2", 25),
-						weatherItem("w3", 30),
-					]),
-				)
-				.registerPostProcessor(async () => ({
-					boost: { w1: -0.3, w2: -0.3 },
-				}))
-
-			const result = await engine.refresh()
-			// w3 (neutral) first, then w1 and w2 (equal negative) in original order
-			expect(result.items.map((i) => i.id)).toEqual(["w3", "w1", "w2"])
-		})
-
-		test("boost works alongside additionalItems and groupedItems", async () => {
-			const extra = calendarItem("c1", "Meeting")
-
-			const engine = new FeedEngine()
-				.register(createWeatherSource([weatherItem("w1", 20), weatherItem("w2", 25)]))
-				.registerPostProcessor(async () => ({
-					additionalItems: [extra],
-					boost: { c1: 1.0 },
-					groupedItems: [{ itemIds: ["w1", "c1"], summary: "Related" }],
-				}))
-
-			const result = await engine.refresh()
-			// c1 boosted to front
-			expect(result.items[0].id).toBe("c1")
-			expect(result.items).toHaveLength(3)
-			expect(result.groupedItems).toEqual([{ itemIds: ["w1", "c1"], summary: "Related" }])
-		})
-	})
-
 	// =============================================================================
 	// PIPELINE ORDERING
 	// =============================================================================
@@ -477,7 +314,7 @@ describe("FeedPostProcessor", () => {
 		test("post-processors run during reactive context updates", async () => {
 			let callCount = 0
 
-			let triggerUpdate: ((entries: readonly ContextEntry[]) => void) | null = null
+			let triggerUpdate: ((update: Record<string, unknown>) => void) | null = null
 
 			const source: FeedSource = {
 				id: "aris.reactive",
@@ -496,7 +333,9 @@ describe("FeedPostProcessor", () => {
 				},
 			}
 
-			const engine = new FeedEngine().register(source).registerPostProcessor(async () => {
+			const engine = new FeedEngine()
+				.register(source)
+				.registerPostProcessor(async () => {
 					callCount++
 					return {}
 				})
@@ -508,7 +347,7 @@ describe("FeedPostProcessor", () => {
 			const countAfterStart = callCount
 
 			// Trigger a reactive context update
-			triggerUpdate!([])
+			triggerUpdate!({ foo: "bar" })
 			await new Promise((resolve) => setTimeout(resolve, 50))
 
 			expect(callCount).toBeGreaterThan(countAfterStart)
@@ -519,7 +358,7 @@ describe("FeedPostProcessor", () => {
 		test("post-processors run during reactive item updates", async () => {
 			let callCount = 0
 
-			let triggerItemsUpdate: ((items: FeedItem[]) => void) | null = null
+			let triggerItemsUpdate: (() => void) | null = null
 
 			const source: FeedSource = {
 				id: "aris.reactive",
@@ -538,7 +377,9 @@ describe("FeedPostProcessor", () => {
 				},
 			}
 
-			const engine = new FeedEngine().register(source).registerPostProcessor(async () => {
+			const engine = new FeedEngine()
+				.register(source)
+				.registerPostProcessor(async () => {
 					callCount++
 					return {}
 				})
@@ -549,7 +390,7 @@ describe("FeedPostProcessor", () => {
 			const countAfterStart = callCount
 
 			// Trigger a reactive items update
-			triggerItemsUpdate!([weatherItem("w1", 25)])
+			triggerItemsUpdate!()
 			await new Promise((resolve) => setTimeout(resolve, 50))
 
 			expect(callCount).toBeGreaterThan(countAfterStart)

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

@@ -1,4 +1,3 @@
-import type { Context } from "./context"
 import type { FeedItem } from "./feed"
 
 export interface ItemGroup {
@@ -15,12 +14,10 @@ export interface FeedEnhancement {
 	groupedItems?: ItemGroup[]
 	/** Item IDs to remove from the feed */
 	suppress?: string[]
-	/** Map of item ID to boost score (-1 to 1). Positive promotes, negative demotes. */
-	boost?: Record<string, number>
 }
 
 /**
  * A function that transforms feed items and produces enhancement directives.
  * Use named functions for meaningful error attribution.
  */
-export type FeedPostProcessor = (items: FeedItem[], context: Context) => Promise<FeedEnhancement>
+export type FeedPostProcessor = (items: FeedItem[]) => Promise<FeedEnhancement>

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

@@ -1,8 +1,8 @@
 import { describe, expect, test } from "bun:test"
 
-import type { ActionDefinition, ContextEntry, ContextKey, FeedItem, FeedSource } from "./index"
+import type { ActionDefinition, Context, ContextKey, FeedItem, FeedSource } from "./index"
 
-import { Context, TimeRelevance, UnknownActionError, contextKey } from "./index"
+import { TimeRelevance, UnknownActionError, contextKey, contextValue } from "./index"
 
 // No-op action methods for test sources
 const noActions = {
@@ -47,7 +47,7 @@ interface SimulatedLocationSource extends FeedSource {
 }
 
 function createLocationSource(): SimulatedLocationSource {
-	let callback: ((entries: readonly ContextEntry[]) => void) | null = null
+	let callback: ((update: Partial<Context>) => 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 = context.get(LocationKey)
+			const location = contextValue(context, LocationKey)
 			if (!location) return null
 
 			const weather = await fetchWeather(location)
-			return [[WeatherKey, weather]]
+			return { [WeatherKey]: weather }
 		},
 
 		async fetchItems(context) {
-			const weather = context.get(WeatherKey)
+			const weather = contextValue(context, WeatherKey)
 			if (!weather) return []
 
 			return [
@@ -122,7 +122,7 @@ function createAlertSource(): FeedSource<AlertFeedItem> {
 		},
 
 		async fetchItems(context) {
-			const weather = context.get(WeatherKey)
+			const weather = contextValue(context, 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[] }> {
-	const context = new Context()
+	let context: Context = { time: new Date() }
 
 	// Run fetchContext in topological order
 	for (const source of graph.sorted) {
-		const entries = await source.fetchContext(context)
-		if (entries) {
-			context.set(entries)
+		const update = await source.fetchContext(context)
+		if (update) {
+			context = { ...context, ...update }
 		}
 	}
 
@@ -265,7 +265,7 @@ describe("FeedSource", () => {
 
 		test("source without context returns null from fetchContext", async () => {
 			const source = createAlertSource()
-			const result = await source.fetchContext(new Context())
+			const result = await source.fetchContext({ time: new Date() })
 			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 = ctx.get(LocationKey)
+					const loc = contextValue(ctx, 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(context.get(LocationKey)).toEqual({
+			expect(contextValue(context, LocationKey)).toEqual({
 				lat: 51.5,
 				lng: -0.1,
 			})
-			expect(context.get(WeatherKey)).toEqual({
+			expect(contextValue(context, WeatherKey)).toEqual({
 				temperature: 20,
 				condition: "sunny",
 			})
@@ -447,10 +447,12 @@ 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
 				},
 			}
@@ -460,7 +462,7 @@ describe("FeedSource", () => {
 			const graph = buildGraph([location, weather])
 			const { context, items } = await refreshGraph(graph)
 
-			expect(context.get(WeatherKey)).toBeUndefined()
+			expect(contextValue(context, WeatherKey)).toBeUndefined()
 			expect(items).toHaveLength(0)
 		})
 	})
@@ -474,7 +476,7 @@ describe("FeedSource", () => {
 				() => {
 					updateCount++
 				},
-				() => new Context(),
+				() => ({ time: new Date() }),
 			)
 
 			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, ContextEntry } from "./context"
+import type { Context } 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: (entries: readonly ContextEntry[]) => void,
+		callback: (update: Partial<Context>) => 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<readonly ContextEntry[] | null>
+	fetchContext(context: Context): Promise<Partial<Context> | null>
 
 	/**
 	 * Subscribe to reactive feed item updates.

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

@@ -1,87 +0,0 @@
-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,20 +23,6 @@ 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.
  *
@@ -50,12 +36,6 @@ export interface Slot {
  *   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,
- *     },
- *   },
  * }
  * ```
  */
@@ -73,6 +53,4 @@ 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 { ContextEntry, ContextKey, ContextKeyPart } from "./context"
-export { Context, contextKey, serializeKey } from "./context"
+export type { Context, ContextKey } from "./context"
+export { contextKey, contextValue } from "./context"
 
 // Actions
 export type { ActionDefinition } from "./action"
 export { UnknownActionError } from "./action"
 
 // Feed
-export type { FeedItem, FeedItemSignals, Slot } from "./feed"
+export type { FeedItem, FeedItemSignals } from "./feed"
 export { TimeRelevance } from "./feed"
 
 // Feed Source

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

@@ -1,6 +1,5 @@
-import type { ContextKey } from "@aris/core"
+import type { Context } from "@aris/core"
 
-import { Context, contextKey } from "@aris/core"
 import { describe, expect, test } from "bun:test"
 
 import type { WeatherKitClient, WeatherKitResponse } from "./weatherkit"
@@ -16,25 +15,14 @@ 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,
 })
 
-function createMockContext(location?: { lat: number; lng: number }): Context {
-	const ctx = new Context(new Date("2026-01-17T00:00:00Z"))
-	if (location) {
-		ctx.set([[LocationKey, { ...location, accuracy: 10 }]])
-	}
-	return ctx
-}
+const createMockContext = (location?: { lat: number; lng: number }): Context => ({
+	time: new Date("2026-01-17T00:00:00Z"),
+	location: location ? { ...location, accuracy: 10 } : undefined,
+})
 
 describe("WeatherKitDataSource", () => {
 	test("returns empty array when location is missing", async () => {
@@ -51,7 +39,7 @@ describe("WeatherKitDataSource", () => {
 			credentials: mockCredentials,
 		})
 
-		expect(dataSource.type).toBe(WeatherFeedItemType.Current)
+		expect(dataSource.type).toBe(WeatherFeedItemType.current)
 	})
 
 	test("throws error if neither client nor credentials provided", () => {
@@ -142,9 +130,9 @@ describe("query() with mocked client", () => {
 		const items = await dataSource.query(context)
 
 		expect(items.length).toBeGreaterThan(0)
-		expect(items.some((i) => i.type === WeatherFeedItemType.Current)).toBe(true)
-		expect(items.some((i) => i.type === WeatherFeedItemType.Hourly)).toBe(true)
-		expect(items.some((i) => i.type === WeatherFeedItemType.Daily)).toBe(true)
+		expect(items.some((i) => i.type === WeatherFeedItemType.current)).toBe(true)
+		expect(items.some((i) => i.type === WeatherFeedItemType.hourly)).toBe(true)
+		expect(items.some((i) => i.type === WeatherFeedItemType.daily)).toBe(true)
 	})
 
 	test("applies hourly and daily limits", async () => {
@@ -157,8 +145,8 @@ describe("query() with mocked client", () => {
 
 		const items = await dataSource.query(context)
 
-		const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.Hourly)
-		const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.Daily)
+		const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.hourly)
+		const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.daily)
 
 		expect(hourlyItems.length).toBe(3)
 		expect(dailyItems.length).toBe(2)
@@ -188,8 +176,8 @@ describe("query() with mocked client", () => {
 			units: Units.imperial,
 		})
 
-		const metricCurrent = metricItems.find((i) => i.type === WeatherFeedItemType.Current)
-		const imperialCurrent = imperialItems.find((i) => i.type === WeatherFeedItemType.Current)
+		const metricCurrent = metricItems.find((i) => i.type === WeatherFeedItemType.current)
+		const imperialCurrent = imperialItems.find((i) => i.type === WeatherFeedItemType.current)
 
 		expect(metricCurrent).toBeDefined()
 		expect(imperialCurrent).toBeDefined()
@@ -215,7 +203,7 @@ describe("query() with mocked client", () => {
 			expect(item.signals!.timeRelevance).toBeDefined()
 		}
 
-		const currentItem = items.find((i) => i.type === WeatherFeedItemType.Current)
+		const currentItem = items.find((i) => i.type === WeatherFeedItemType.current)
 		expect(currentItem).toBeDefined()
 		expect(currentItem!.signals!.urgency).toBeGreaterThanOrEqual(0.5)
 	})

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

@@ -1,6 +1,6 @@
-import type { Context, ContextKey, DataSource, FeedItemSignals } from "@aris/core"
+import type { Context, DataSource, FeedItemSignals } from "@aris/core"
 
-import { TimeRelevance, contextKey } from "@aris/core"
+import { TimeRelevance } from "@aris/core"
 
 import {
 	WeatherFeedItemType,
@@ -40,18 +40,11 @@ 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
 
-	readonly type = WeatherFeedItemType.Current
+	readonly type = WeatherFeedItemType.current
 	private readonly client: WeatherKitClient
 	private readonly hourlyLimit: number
 	private readonly dailyLimit: number
@@ -66,8 +59,7 @@ export class WeatherKitDataSource implements DataSource<WeatherFeedItem, Weather
 	}
 
 	async query(context: Context, config: WeatherKitQueryConfig = {}): Promise<WeatherFeedItem[]> {
-		const location = context.get(LocationKey)
-		if (!location) {
+		if (!context.location) {
 			return []
 		}
 
@@ -75,8 +67,8 @@ export class WeatherKitDataSource implements DataSource<WeatherFeedItem, Weather
 		const timestamp = context.time
 
 		const response = await this.client.fetch({
-			lat: location.lat,
-			lng: location.lng,
+			lat: context.location.lat,
+			lng: context.location.lng,
 		})
 
 		const items: WeatherFeedItem[] = []
@@ -236,7 +228,7 @@ function createCurrentWeatherFeedItem(
 
 	return {
 		id: `weather-current-${timestamp.getTime()}`,
-		type: WeatherFeedItemType.Current,
+		type: WeatherFeedItemType.current,
 		timestamp,
 		data: {
 			conditionCode: current.conditionCode,
@@ -270,7 +262,7 @@ function createHourlyWeatherFeedItem(
 
 	return {
 		id: `weather-hourly-${timestamp.getTime()}-${index}`,
-		type: WeatherFeedItemType.Hourly,
+		type: WeatherFeedItemType.hourly,
 		timestamp,
 		data: {
 			forecastTime: new Date(hourly.forecastStart),
@@ -304,7 +296,7 @@ function createDailyWeatherFeedItem(
 
 	return {
 		id: `weather-daily-${timestamp.getTime()}-${index}`,
-		type: WeatherFeedItemType.Daily,
+		type: WeatherFeedItemType.daily,
 		timestamp,
 		data: {
 			forecastDate: new Date(daily.forecastStart),
@@ -331,7 +323,7 @@ function createWeatherAlertFeedItem(alert: WeatherAlert, timestamp: Date): Weath
 
 	return {
 		id: `weather-alert-${alert.id}`,
-		type: WeatherFeedItemType.Alert,
+		type: WeatherFeedItemType.alert,
 		timestamp,
 		data: {
 			alertId: alert.id,

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

@@ -3,10 +3,10 @@ import type { FeedItem } from "@aris/core"
 import type { Certainty, ConditionCode, PrecipitationType, Severity, Urgency } from "./weatherkit"
 
 export const WeatherFeedItemType = {
-	Current: "weather-current",
-	Hourly: "weather-hourly",
-	Daily: "weather-daily",
-	Alert: "weather-alert",
+	current: "weather-current",
+	hourly: "weather-hourly",
+	daily: "weather-daily",
+	alert: "weather-alert",
 } as const
 
 export type WeatherFeedItemType = (typeof WeatherFeedItemType)[keyof typeof WeatherFeedItemType]
@@ -28,7 +28,7 @@ export type CurrentWeatherData = {
 }
 
 export interface CurrentWeatherFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Current,
+	typeof WeatherFeedItemType.current,
 	CurrentWeatherData
 > {}
 
@@ -49,7 +49,7 @@ export type HourlyWeatherData = {
 }
 
 export interface HourlyWeatherFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Hourly,
+	typeof WeatherFeedItemType.hourly,
 	HourlyWeatherData
 > {}
 
@@ -68,7 +68,7 @@ export type DailyWeatherData = {
 }
 
 export interface DailyWeatherFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Daily,
+	typeof WeatherFeedItemType.daily,
 	DailyWeatherData
 > {}
 
@@ -86,7 +86,7 @@ export type WeatherAlertData = {
 }
 
 export interface WeatherAlertFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Alert,
+	typeof WeatherFeedItemType.alert,
 	WeatherAlertData
 > {}
 

packages/aris-feed-enhancers/package.json

@@ -1,17 +0,0 @@
-{
-	"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

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

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

@@ -1,704 +0,0 @@
-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

@@ -1,595 +0,0 @@
-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/scripts/test-live.ts

@@ -5,8 +5,6 @@
  *   bun run test-live.ts
  */
 
-import { Context } from "@aris/core"
-
 import { CalDavSource } from "../src/index.ts"
 
 const serverUrl = prompt("CalDAV server URL:")
@@ -29,7 +27,7 @@ const source = new CalDavSource({
 	lookAheadDays,
 })
 
-const context = new Context()
+const context = { time: new Date() }
 
 console.log(`\nFetching from ${serverUrl} as ${username} (lookAheadDays=${lookAheadDays})...\n`)
 

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

@@ -1,6 +1,6 @@
-import type { ContextEntry } from "@aris/core"
+import type { Context } from "@aris/core"
 
-import { Context, TimeRelevance } from "@aris/core"
+import { TimeRelevance, contextValue } from "@aris/core"
 import { describe, expect, test } from "bun:test"
 import { readFileSync } from "node:fs"
 import { join } from "node:path"
@@ -13,21 +13,14 @@ import type {
 } from "./types.ts"
 
 import { CalDavSource, computeSignals } from "./caldav-source.ts"
-import { CalDavCalendarKey, type CalendarContext } from "./calendar-context.ts"
+import { CalDavCalendarKey } 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 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
+	return { time }
 }
 
 class MockDAVClient implements CalDavDAVClient {
@@ -309,8 +302,8 @@ describe("CalDavSource.fetchContext", () => {
 	test("returns empty context when no calendars exist", async () => {
 		const client = new MockDAVClient([], {})
 		const source = createSource(client)
-		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = extractCalendar(entries)
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
 
 		expect(calendar).toBeDefined()
 		expect(calendar!.inProgress).toEqual([])
@@ -327,8 +320,8 @@ describe("CalDavSource.fetchContext", () => {
 		const source = createSource(client)
 
 		// 14:30 is during the 14:00-15:00 event
-		const entries = await source.fetchContext(createContext(new Date("2026-01-15T14:30:00Z")))
-		const calendar = extractCalendar(entries)
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T14:30:00Z")))
+		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
 
 		expect(calendar!.inProgress).toHaveLength(1)
 		expect(calendar!.inProgress[0]!.title).toBe("Team Standup")
@@ -342,8 +335,8 @@ describe("CalDavSource.fetchContext", () => {
 		const source = createSource(client)
 
 		// 12:00 is before the 14:00 event
-		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = extractCalendar(entries)
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
 
 		expect(calendar!.inProgress).toHaveLength(0)
 		expect(calendar!.nextEvent).not.toBeNull()
@@ -357,8 +350,8 @@ describe("CalDavSource.fetchContext", () => {
 		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
 		const source = createSource(client)
 
-		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = extractCalendar(entries)
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
 
 		expect(calendar!.inProgress).toHaveLength(0)
 		expect(calendar!.nextEvent).toBeNull()
@@ -376,8 +369,8 @@ describe("CalDavSource.fetchContext", () => {
 		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
 		const source = createSource(client)
 
-		const entries = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
-		const calendar = extractCalendar(entries)
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalDavCalendarKey)
 
 		expect(calendar!.todayEventCount).toBe(2)
 		expect(calendar!.hasTodayEvents).toBe(true)

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

@@ -1,13 +1,13 @@
-import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
+import { TimeRelevance, UnknownActionError } from "@aris/core"
 import { DAVClient } from "tsdav"
 
 import type { CalDavDAVClient, CalDavEventData, CalDavFeedItem } from "./types.ts"
+import { CalDavEventStatus } from "./types.ts"
 
 import { CalDavCalendarKey, type CalendarContext } from "./calendar-context.ts"
 import { parseICalEvents } from "./ical-parser.ts"
-import { CalDavEventStatus, CalDavFeedItemType } from "./types.ts"
 
 // -- Source options --
 
@@ -93,20 +93,17 @@ export class CalDavSource implements FeedSource<CalDavFeedItem> {
 		throw new UnknownActionError(actionId)
 	}
 
-	async fetchContext(context: Context): Promise<readonly ContextEntry[] | null> {
+	async fetchContext(context: Context): Promise<Partial<Context> | null> {
 		const events = await this.fetchEvents(context)
 		if (events.length === 0) {
-			return [
-				[
-					CalDavCalendarKey,
-					{
+			return {
+				[CalDavCalendarKey]: {
 					inProgress: [],
 					nextEvent: null,
 					hasTodayEvents: false,
 					todayEventCount: 0,
 				},
-				],
-			]
+			}
 		}
 
 		const now = context.time
@@ -124,7 +121,7 @@ export class CalDavSource implements FeedSource<CalDavFeedItem> {
 			todayEventCount: events.length,
 		}
 
-		return [[CalDavCalendarKey, calendarContext]]
+		return { [CalDavCalendarKey]: calendarContext }
 	}
 
 	async fetchItems(context: Context): Promise<CalDavFeedItem[]> {
@@ -343,7 +340,7 @@ export function computeSignals(
 function createFeedItem(event: CalDavEventData, now: Date, timeZone?: string): CalDavFeedItem {
 	return {
 		id: `caldav-event-${event.uid}${event.recurrenceId ? `-${event.recurrenceId}` : ""}`,
-		type: CalDavFeedItemType.Event,
+		type: "caldav-event",
 		timestamp: now,
 		data: event,
 		signals: computeSignals(event, now, timeZone),

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

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

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

@@ -5,7 +5,6 @@ export {
 	AttendeeRole,
 	AttendeeStatus,
 	CalDavEventStatus,
-	CalDavFeedItemType,
 	type CalDavAlarm,
 	type CalDavAttendee,
 	type CalDavDAVCalendar,

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

@@ -64,17 +64,9 @@ export interface CalDavEventData extends Record<string, unknown> {
 	recurrenceId: string | null
 }
 
-// -- Feed item type --
-
-export const CalDavFeedItemType = {
-	Event: "caldav-event",
-} as const
-
-export type CalDavFeedItemType = (typeof CalDavFeedItemType)[keyof typeof CalDavFeedItemType]
-
 // -- Feed item --
 
-export type CalDavFeedItem = FeedItem<typeof CalDavFeedItemType.Event, CalDavEventData>
+export type CalDavFeedItem = FeedItem<"caldav-event", CalDavEventData>
 
 // -- DAV client interface --
 

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("aris.google-calendar", "nextEvent")
+export const NextEventKey: ContextKey<NextEvent> = contextKey("nextEvent")

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

@@ -3,19 +3,19 @@ import type { FeedItem } from "@aris/core"
 import type { CalendarEventData } from "./types"
 
 export const CalendarFeedItemType = {
-	Event: "calendar-event",
-	AllDay: "calendar-all-day",
+	event: "calendar-event",
+	allDay: "calendar-all-day",
 } as const
 
 export type CalendarFeedItemType = (typeof CalendarFeedItemType)[keyof typeof CalendarFeedItemType]
 
 export interface CalendarEventFeedItem extends FeedItem<
-	typeof CalendarFeedItemType.Event,
+	typeof CalendarFeedItemType.event,
 	CalendarEventData
 > {}
 
 export interface CalendarAllDayFeedItem extends FeedItem<
-	typeof CalendarFeedItemType.AllDay,
+	typeof CalendarFeedItemType.allDay,
 	CalendarEventData
 > {}
 

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

@@ -1,10 +1,10 @@
-import { Context, TimeRelevance } from "@aris/core"
+import { TimeRelevance, contextValue, type Context } 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, type NextEvent } from "./calendar-context"
+import { NextEventKey } 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 new Context(time ?? NOW)
+	return { time: time ?? NOW }
 }
 
 describe("GoogleCalendarSource", () => {
@@ -69,7 +69,7 @@ describe("GoogleCalendarSource", () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
 			const items = await source.fetchItems(createContext())
 
-			const timedItems = items.filter((i) => i.type === CalendarFeedItemType.Event)
+			const timedItems = items.filter((i) => i.type === CalendarFeedItemType.event)
 			expect(timedItems.length).toBe(4)
 		})
 
@@ -77,7 +77,7 @@ describe("GoogleCalendarSource", () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
 			const items = await source.fetchItems(createContext())
 
-			const allDayItems = items.filter((i) => i.type === CalendarFeedItemType.AllDay)
+			const allDayItems = items.filter((i) => i.type === CalendarFeedItemType.allDay)
 			expect(allDayItems.length).toBe(1)
 		})
 
@@ -229,16 +229,15 @@ describe("GoogleCalendarSource", () => {
 
 		test("returns next upcoming timed event (not ongoing)", async () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
-			const entries = await source.fetchContext(createContext())
+			const result = await source.fetchContext(createContext())
 
-			expect(entries).not.toBeNull()
-			expect(entries).toHaveLength(1)
-			const [key, nextEvent] = entries![0]! as [typeof NextEventKey, NextEvent]
-			expect(key).toEqual(NextEventKey)
+			expect(result).not.toBeNull()
+			const nextEvent = contextValue(result! as Context, NextEventKey)
+			expect(nextEvent).toBeDefined()
 			// evt-soon starts at 10:10, which is the nearest future timed event
-			expect(nextEvent.title).toBe("1:1 with Manager")
-			expect(nextEvent.minutesUntilStart).toBe(10)
-			expect(nextEvent.location).toBeNull()
+			expect(nextEvent!.title).toBe("1:1 with Manager")
+			expect(nextEvent!.minutesUntilStart).toBe(10)
+			expect(nextEvent!.location).toBeNull()
 		})
 
 		test("includes location when available", async () => {
@@ -256,11 +255,12 @@ describe("GoogleCalendarSource", () => {
 			const source = new GoogleCalendarSource({
 				client: createMockClient({ primary: events }),
 			})
-			const entries = await source.fetchContext(createContext())
+			const result = await source.fetchContext(createContext())
 
-			expect(entries).not.toBeNull()
-			const [, nextEvent] = entries![0]! as [typeof NextEventKey, NextEvent]
-			expect(nextEvent.location).toBe("123 Main St")
+			expect(result).not.toBeNull()
+			const nextEvent = contextValue(result! as Context, NextEventKey)
+			expect(nextEvent).toBeDefined()
+			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, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
+import { 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 = context.get(NextEventKey)
+ * const next = contextValue(context, 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<readonly ContextEntry[] | null> {
+	async fetchContext(context: Context): Promise<Partial<Context> | 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[]> {
@@ -209,7 +209,7 @@ function createFeedItem(
 	nowMs: number,
 	lookaheadMs: number,
 ): CalendarFeedItem {
-	const itemType = event.isAllDay ? CalendarFeedItemType.AllDay : CalendarFeedItemType.Event
+	const itemType = event.isAllDay ? CalendarFeedItemType.allDay : CalendarFeedItemType.event
 
 	return {
 		id: `calendar-${event.calendarId}-${event.eventId}`,

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

@@ -1,6 +1,7 @@
 export { NextEventKey, type NextEvent } from "./calendar-context"
 export {
 	CalendarFeedItemType,
+	type CalendarFeedItemType as CalendarFeedItemTypeType,
 	type CalendarAllDayFeedItem,
 	type CalendarEventFeedItem,
 	type CalendarFeedItem,
@@ -9,6 +10,7 @@ export { DefaultGoogleCalendarClient } from "./google-calendar-api"
 export { GoogleCalendarSource, type GoogleCalendarSourceOptions } from "./google-calendar-source"
 export {
 	EventStatus,
+	type EventStatus as EventStatusType,
 	type ApiCalendarEvent,
 	type ApiEventDateTime,
 	type CalendarEventData,

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

@@ -1,8 +1,6 @@
 import { describe, expect, mock, test } from "bun:test"
 
-import type { Location } from "./types.ts"
-
-import { LocationKey, LocationSource } from "./location-source.ts"
+import { LocationKey, LocationSource, type Location } from "./location-source.ts"
 
 function createLocation(overrides: Partial<Location> = {}): Location {
 	return {
@@ -41,8 +39,8 @@ describe("LocationSource", () => {
 			const location = createLocation()
 			source.pushLocation(location)
 
-			const entries = await source.fetchContext()
-			expect(entries).toEqual([[LocationKey, location]])
+			const context = await source.fetchContext()
+			expect(context).toEqual({ [LocationKey]: location })
 		})
 	})
 
@@ -67,7 +65,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, ContextEntry, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedSource } from "@aris/core"
 
-import { Context, UnknownActionError, contextKey, type ContextKey } from "@aris/core"
+import { UnknownActionError, contextKey, type ContextKey } from "@aris/core"
 import { type } from "arktype"
 
 import { Location, type LocationSourceOptions } from "./types.ts"
 
-export const LocationKey: ContextKey<Location> = contextKey("aris.location", "location")
+export const LocationKey: ContextKey<Location> = contextKey("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<(entries: readonly ContextEntry[]) => void>()
+	private listeners = new Set<(update: Partial<Context>) => void>()
 
 	constructor(options: LocationSourceOptions = {}) {
 		this.historySize = options.historySize ?? 1
@@ -59,9 +59,8 @@ 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(entries)
+			listener({ [LocationKey]: location })
 		})
 	}
 
@@ -79,16 +78,16 @@ export class LocationSource implements FeedSource {
 		return this.locations
 	}
 
-	onContextUpdate(callback: (entries: readonly ContextEntry[]) => void): () => void {
+	onContextUpdate(callback: (update: Partial<Context>) => void): () => void {
 		this.listeners.add(callback)
 		return () => {
 			this.listeners.delete(callback)
 		}
 	}
 
-	async fetchContext(): Promise<readonly ContextEntry[] | null> {
+	async fetchContext(): Promise<Partial<Context> | null> {
 		if (this.lastLocation) {
-			return [[LocationKey, this.lastLocation]]
+			return { [LocationKey]: this.lastLocation }
 		}
 		return null
 	}

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

@@ -1,13 +1,12 @@
 export { TflSource } from "./tfl-source.ts"
 export { TflApi } from "./tfl-api.ts"
 export type { TflLineId } from "./tfl-api.ts"
-export {
-	TflFeedItemType,
-	type ITflApi,
-	type StationLocation,
-	type TflAlertData,
-	type TflAlertFeedItem,
-	type TflAlertSeverity,
-	type TflLineStatus,
-	type TflSourceOptions,
+export type {
+	ITflApi,
+	StationLocation,
+	TflAlertData,
+	TflAlertFeedItem,
+	TflAlertSeverity,
+	TflLineStatus,
+	TflSourceOptions,
 } from "./types.ts"

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

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

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

@@ -1,6 +1,6 @@
-import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
+import { TimeRelevance, UnknownActionError, contextValue } from "@aris/core"
 import { LocationKey } from "@aris/source-location"
 import { type } from "arktype"
 
@@ -15,7 +15,6 @@ import type {
 } from "./types.ts"
 
 import { TflApi, lineId } from "./tfl-api.ts"
-import { TflFeedItemType } from "./types.ts"
 
 const setLinesInput = lineId.array()
 
@@ -112,7 +111,7 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 		}
 	}
 
-	async fetchContext(): Promise<readonly ContextEntry[] | null> {
+	async fetchContext(): Promise<null> {
 		return null
 	}
 
@@ -129,7 +128,7 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 			this.client.fetchStations(),
 		])
 
-		const location = context.get(LocationKey)
+		const location = contextValue(context, LocationKey)
 
 		const items: TflAlertFeedItem[] = statuses.map((status) => {
 			const closestStationDistance = location
@@ -151,7 +150,7 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 
 			return {
 				id: `tfl-alert-${status.lineId}-${status.severity}`,
-				type: TflFeedItemType.Alert,
+				type: "tfl-alert",
 				timestamp: context.time,
 				data,
 				signals,

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

@@ -20,13 +20,7 @@ export interface TflAlertData extends Record<string, unknown> {
 	closestStationDistance: number | null
 }
 
-export const TflFeedItemType = {
-	Alert: "tfl-alert",
-} as const
-
-export type TflFeedItemType = (typeof TflFeedItemType)[keyof typeof TflFeedItemType]
-
-export type TflAlertFeedItem = FeedItem<typeof TflFeedItemType.Alert, TflAlertData>
+export type TflAlertFeedItem = FeedItem<"tfl-alert", TflAlertData>
 
 export interface TflSourceOptions {
 	apiKey?: string

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

@@ -1,181 +0,0 @@
-#!/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/feed-items.ts

@@ -3,10 +3,10 @@ import type { FeedItem } from "@aris/core"
 import type { Certainty, ConditionCode, PrecipitationType, Severity, Urgency } from "./weatherkit"
 
 export const WeatherFeedItemType = {
-	Current: "weather-current",
-	Hourly: "weather-hourly",
-	Daily: "weather-daily",
-	Alert: "weather-alert",
+	current: "weather-current",
+	hourly: "weather-hourly",
+	daily: "weather-daily",
+	alert: "weather-alert",
 } as const
 
 export type WeatherFeedItemType = (typeof WeatherFeedItemType)[keyof typeof WeatherFeedItemType]
@@ -28,7 +28,7 @@ export type CurrentWeatherData = {
 }
 
 export interface CurrentWeatherFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Current,
+	typeof WeatherFeedItemType.current,
 	CurrentWeatherData
 > {}
 
@@ -49,7 +49,7 @@ export type HourlyWeatherData = {
 }
 
 export interface HourlyWeatherFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Hourly,
+	typeof WeatherFeedItemType.hourly,
 	HourlyWeatherData
 > {}
 
@@ -68,7 +68,7 @@ export type DailyWeatherData = {
 }
 
 export interface DailyWeatherFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Daily,
+	typeof WeatherFeedItemType.daily,
 	DailyWeatherData
 > {}
 
@@ -86,7 +86,7 @@ export type WeatherAlertData = {
 }
 
 export interface WeatherAlertFeedItem extends FeedItem<
-	typeof WeatherFeedItemType.Alert,
+	typeof WeatherFeedItemType.alert,
 	WeatherAlertData
 > {}
 

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

@@ -1,8 +1,14 @@
 export { WeatherKey, type Weather } from "./weather-context"
-export { WeatherSource, Units, type WeatherSourceOptions } from "./weather-source"
+export {
+	WeatherSource,
+	Units,
+	type Units as UnitsType,
+	type WeatherSourceOptions,
+} from "./weather-source"
 
 export {
 	WeatherFeedItemType,
+	type WeatherFeedItemType as WeatherFeedItemTypeType,
 	type WeatherFeedItem,
 	type CurrentWeatherFeedItem,
 	type CurrentWeatherData,
@@ -21,6 +27,11 @@ export {
 	Certainty,
 	PrecipitationType,
 	DefaultWeatherKitClient,
+	type ConditionCode as ConditionCodeType,
+	type Severity as SeverityType,
+	type Urgency as UrgencyType,
+	type Certainty as CertaintyType,
+	type PrecipitationType as PrecipitationTypeType,
 	type WeatherKitClient,
 	type WeatherKitCredentials,
 	type WeatherKitQueryOptions,

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

@@ -1,7 +0,0 @@
-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("aris.weather", "weather")
+export const WeatherKey: ContextKey<Weather> = contextKey("weather")

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

@@ -1,6 +1,4 @@
-import type { FeedSource } from "@aris/core"
-
-import { Context } from "@aris/core"
+import { contextValue, type Context } from "@aris/core"
 import { LocationKey } from "@aris/source-location"
 import { describe, expect, test } from "bun:test"
 
@@ -8,7 +6,7 @@ import type { WeatherKitClient, WeatherKitResponse } from "./weatherkit"
 
 import fixture from "../fixtures/san-francisco.json"
 import { WeatherFeedItemType } from "./feed-items"
-import { WeatherKey, type Weather } from "./weather-context"
+import { WeatherKey } from "./weather-context"
 import { WeatherSource, Units } from "./weather-source"
 
 const mockCredentials = {
@@ -25,9 +23,9 @@ function createMockClient(response: WeatherKitResponse): WeatherKitClient {
 }
 
 function createMockContext(location?: { lat: number; lng: number }): Context {
-	const ctx = new Context(new Date("2026-01-17T00:00:00Z"))
+	const ctx: Context = { time: new Date("2026-01-17T00:00:00Z") }
 	if (location) {
-		ctx.set([[LocationKey, { ...location, accuracy: 10, timestamp: new Date() }]])
+		ctx[LocationKey] = { ...location, accuracy: 10, timestamp: new Date() }
 	}
 	return ctx
 }
@@ -65,19 +63,18 @@ describe("WeatherSource", () => {
 			const source = new WeatherSource({ client: mockClient })
 			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
 
-			const entries = await source.fetchContext(context)
-			expect(entries).not.toBeNull()
-			expect(entries).toHaveLength(1)
+			const result = await source.fetchContext(context)
+			expect(result).not.toBeNull()
+			const weather = contextValue(result! as Context, WeatherKey)
 
-			const [key, weather] = entries![0]! as [typeof WeatherKey, Weather]
-			expect(key).toEqual(WeatherKey)
-			expect(typeof weather.temperature).toBe("number")
-			expect(typeof weather.temperatureApparent).toBe("number")
-			expect(typeof weather.condition).toBe("string")
-			expect(typeof weather.humidity).toBe("number")
-			expect(typeof weather.uvIndex).toBe("number")
-			expect(typeof weather.windSpeed).toBe("number")
-			expect(typeof weather.daylight).toBe("boolean")
+			expect(weather).toBeDefined()
+			expect(typeof weather!.temperature).toBe("number")
+			expect(typeof weather!.temperatureApparent).toBe("number")
+			expect(typeof weather!.condition).toBe("string")
+			expect(typeof weather!.humidity).toBe("number")
+			expect(typeof weather!.uvIndex).toBe("number")
+			expect(typeof weather!.windSpeed).toBe("number")
+			expect(typeof weather!.daylight).toBe("boolean")
 		})
 
 		test("converts temperature to imperial", async () => {
@@ -87,12 +84,12 @@ describe("WeatherSource", () => {
 			})
 			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
 
-			const entries = await source.fetchContext(context)
-			expect(entries).not.toBeNull()
+			const result = await source.fetchContext(context)
+			expect(result).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)
 		})
 	})
 
@@ -113,9 +110,9 @@ describe("WeatherSource", () => {
 			const items = await source.fetchItems(context)
 
 			expect(items.length).toBeGreaterThan(0)
-			expect(items.some((i) => i.type === WeatherFeedItemType.Current)).toBe(true)
-			expect(items.some((i) => i.type === WeatherFeedItemType.Hourly)).toBe(true)
-			expect(items.some((i) => i.type === WeatherFeedItemType.Daily)).toBe(true)
+			expect(items.some((i) => i.type === WeatherFeedItemType.current)).toBe(true)
+			expect(items.some((i) => i.type === WeatherFeedItemType.hourly)).toBe(true)
+			expect(items.some((i) => i.type === WeatherFeedItemType.daily)).toBe(true)
 		})
 
 		test("applies hourly and daily limits", async () => {
@@ -128,8 +125,8 @@ describe("WeatherSource", () => {
 
 			const items = await source.fetchItems(context)
 
-			const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.Hourly)
-			const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.Daily)
+			const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.hourly)
+			const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.daily)
 
 			expect(hourlyItems.length).toBe(3)
 			expect(dailyItems.length).toBe(2)
@@ -161,7 +158,7 @@ describe("WeatherSource", () => {
 				expect(item.signals!.timeRelevance).toBeDefined()
 			}
 
-			const currentItem = items.find((i) => i.type === WeatherFeedItemType.Current)
+			const currentItem = items.find((i) => i.type === WeatherFeedItemType.current)
 			expect(currentItem).toBeDefined()
 			expect(currentItem!.signals!.urgency).toBeGreaterThanOrEqual(0.5)
 		})
@@ -176,44 +173,16 @@ 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: FeedSource = new WeatherSource({ credentials: mockCredentials })
+			const source = new WeatherSource({ credentials: mockCredentials })
 			expect(source.onContextUpdate).toBeUndefined()
 		})
 
 		test("does not implement onItemsUpdate", () => {
-			const source: FeedSource = new WeatherSource({ credentials: mockCredentials })
+			const source = new WeatherSource({ credentials: mockCredentials })
 			expect(source.onItemsUpdate).toBeUndefined()
 		})
 	})

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

@@ -1,10 +1,9 @@
-import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
 
-import { Context, TimeRelevance, UnknownActionError } from "@aris/core"
+import { TimeRelevance, UnknownActionError, contextValue } 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,
@@ -87,7 +86,7 @@ const MODERATE_CONDITIONS = new Set<ConditionCode>([
  * })
  *
  * // Access weather context in downstream sources
- * const weather = context.get(WeatherKey)
+ * const weather = contextValue(context, WeatherKey)
  * if (weather?.condition === "Rain") {
  *   // suggest umbrella
  * }
@@ -120,8 +119,8 @@ export class WeatherSource implements FeedSource<WeatherFeedItem> {
 		throw new UnknownActionError(actionId)
 	}
 
-	async fetchContext(context: Context): Promise<readonly ContextEntry[] | null> {
-		const location = context.get(LocationKey)
+	async fetchContext(context: Context): Promise<Partial<Context> | null> {
+		const location = contextValue(context, LocationKey)
 		if (!location) {
 			return null
 		}
@@ -148,11 +147,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 = context.get(LocationKey)
+		const location = contextValue(context, LocationKey)
 		if (!location) {
 			return []
 		}
@@ -292,7 +291,7 @@ function createCurrentWeatherFeedItem(
 
 	return {
 		id: `weather-current-${timestamp.getTime()}`,
-		type: WeatherFeedItemType.Current,
+		type: WeatherFeedItemType.current,
 		timestamp,
 		data: {
 			conditionCode: current.conditionCode,
@@ -310,12 +309,6 @@ function createCurrentWeatherFeedItem(
 			windSpeed: convertSpeed(current.windSpeed, units),
 		},
 		signals,
-		slots: {
-			insight: {
-				description: currentWeatherInsightPrompt,
-				content: null,
-			},
-		},
 	}
 }
 
@@ -332,7 +325,7 @@ function createHourlyWeatherFeedItem(
 
 	return {
 		id: `weather-hourly-${timestamp.getTime()}-${index}`,
-		type: WeatherFeedItemType.Hourly,
+		type: WeatherFeedItemType.hourly,
 		timestamp,
 		data: {
 			forecastTime: new Date(hourly.forecastStart),
@@ -366,7 +359,7 @@ function createDailyWeatherFeedItem(
 
 	return {
 		id: `weather-daily-${timestamp.getTime()}-${index}`,
-		type: WeatherFeedItemType.Daily,
+		type: WeatherFeedItemType.daily,
 		timestamp,
 		data: {
 			forecastDate: new Date(daily.forecastStart),
@@ -393,7 +386,7 @@ function createWeatherAlertFeedItem(alert: WeatherAlert, timestamp: Date): Weath
 
 	return {
 		id: `weather-alert-${alert.id}`,
-		type: WeatherFeedItemType.Alert,
+		type: WeatherFeedItemType.alert,
 		timestamp,
 		data: {
 			alertId: alert.id,