docs: agent vision and enhancement architecture

Rewrite ai-agent-ideas.md with focus on proactive,
personable assistant behaviors. Add slot-based LLM
enhancement system to architecture-draft.md.

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

bun.lock

@@ -89,6 +89,15 @@
         "arktype": "^2.1.0",
       },
     },
+    "packages/aris-source-apple-calendar": {
+      "name": "@aris/source-apple-calendar",
+      "version": "0.0.0",
+      "dependencies": {
+        "@aris/core": "workspace:*",
+        "ical.js": "^2.1.0",
+        "tsdav": "^2.1.7",
+      },
+    },
     "packages/aris-source-google-calendar": {
       "name": "@aris/source-google-calendar",
       "version": "0.0.0",
@@ -135,6 +144,8 @@
 
     "@aris/data-source-weatherkit": ["@aris/data-source-weatherkit@workspace:packages/aris-data-source-weatherkit"],
 
+    "@aris/source-apple-calendar": ["@aris/source-apple-calendar@workspace:packages/aris-source-apple-calendar"],
+
     "@aris/source-google-calendar": ["@aris/source-google-calendar@workspace:packages/aris-source-google-calendar"],
 
     "@aris/source-location": ["@aris/source-location@workspace:packages/aris-source-location"],
@@ -899,6 +910,8 @@
 
     "bare-events": ["bare-events@2.8.2", "", { "peerDependencies": { "bare-abort-controller": "*" }, "optionalPeers": ["bare-abort-controller"] }, "sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ=="],
 
+    "base-64": ["base-64@1.0.0", "", {}, "sha512-kwDPIFCGx0NZHog36dj+tHiwP4QMzsZ3AgMViUBKI0+V5n4U0ufTCUMhnQ04diaRI8EX/QcPfql7zlhZ7j4zgg=="],
+
     "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
 
     "baseline-browser-mapping": ["baseline-browser-mapping@2.9.19", "", { "bin": { "baseline-browser-mapping": "dist/cli.js" } }, "sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg=="],
@@ -1011,7 +1024,7 @@
 
     "create-require": ["create-require@1.1.1", "", {}, "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ=="],
 
-    "cross-fetch": ["cross-fetch@3.2.0", "", { "dependencies": { "node-fetch": "^2.7.0" } }, "sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q=="],
+    "cross-fetch": ["cross-fetch@4.1.0", "", { "dependencies": { "node-fetch": "^2.7.0" } }, "sha512-uKm5PU+MHTootlWEY+mZ4vvXoCn4fLQxT9dSc1sXVMSFkINTJVN8cAQROpwcKm8bJ/c7rgZVIBWzH5T78sNZZw=="],
 
     "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
 
@@ -1389,6 +1402,8 @@
 
     "hyphenate-style-name": ["hyphenate-style-name@1.1.0", "", {}, "sha512-WDC/ui2VVRrz3jOVi+XtjqkDjiVjTtFaAGiW37k6b+ohyQ5wYDOGkvCZa8+H0nx3gyvv0+BST9xuOgIyGQ00gw=="],
 
+    "ical.js": ["ical.js@2.2.1", "", {}, "sha512-yK/UlPbEs316igb/tjRgbFA8ZV75rCsBJp/hWOatpyaPNlgw0dGDmU+FoicOcwX4xXkeXOkYiOmCqNPFpNPkQg=="],
+
     "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],
 
     "ignore": ["ignore@5.3.0", "", {}, "sha512-g7dmpshy+gD7mh88OC9NwSGTKoc3kyLAZQRU1mt53Aw/vnvfXnbC+F/7F7QoYVKbV+KNvJx8wArewKy1vXMtlg=="],
@@ -2163,6 +2178,8 @@
 
     "tsconfig-paths": ["tsconfig-paths@3.15.0", "", { "dependencies": { "@types/json5": "^0.0.29", "json5": "^1.0.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } }, "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg=="],
 
+    "tsdav": ["tsdav@2.1.8", "", { "dependencies": { "base-64": "1.0.0", "cross-fetch": "4.1.0", "debug": "4.4.3", "xml-js": "1.6.11" } }, "sha512-zvQvhZLzTaEmNNgJbBlUYT/JOq9Xpw/xkxCqs7IT2d2/7o7pss0iZOlZXuHJ5VcvSvTny42Vc6+6GyzZcrCJ1g=="],
+
     "tslib": ["tslib@2.6.2", "", {}, "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="],
 
     "tunnel-agent": ["tunnel-agent@0.6.0", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w=="],
@@ -2285,6 +2302,8 @@
 
     "xcode": ["xcode@3.0.1", "", { "dependencies": { "simple-plist": "^1.1.0", "uuid": "^7.0.3" } }, "sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA=="],
 
+    "xml-js": ["xml-js@1.6.11", "", { "dependencies": { "sax": "^1.2.4" }, "bin": { "xml-js": "./bin/cli.js" } }, "sha512-7rVi2KMfwfWFl+GpPg6m80IVMWXLRjO+PxTq7V2CDhoGak0wzYzFgUY2m4XJ47OGdXd8eLE8EmwfAmdjw7lC1g=="],
+
     "xml2js": ["xml2js@0.6.0", "", { "dependencies": { "sax": ">=0.6.0", "xmlbuilder": "~11.0.0" } }, "sha512-eLTh0kA8uHceqesPqSE+VvO1CDDJWMwlQfB6LuN6T8w6MaDJ8Txm8P7s5cHD0miF0V+GGTZrDQfxPZQVsur33w=="],
 
     "xmlbuilder": ["xmlbuilder@14.0.0", "", {}, "sha512-ts+B2rSe4fIckR6iquDjsKbQFK2NlUk6iG5nf14mDEyldgoc2nEKZ3jZWMPTxGQwVgToSjt6VGIho1H8/fNFTg=="],
@@ -2613,6 +2632,8 @@
 
     "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
 
+    "fbjs/cross-fetch": ["cross-fetch@3.2.0", "", { "dependencies": { "node-fetch": "^2.7.0" } }, "sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q=="],
+
     "fbjs/promise": ["promise@7.3.1", "", { "dependencies": { "asap": "~2.0.3" } }, "sha512-nolQXZ/4L+bP/UGlkfaIujX9BKxGwmQ9OT4mOt5yvy8iK1h3wqTEJCijzGANTCCl9nWjY41juyAn2K3Q1hLLTg=="],
 
     "figures/escape-string-regexp": ["escape-string-regexp@1.0.5", "", {}, "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg=="],
@@ -2939,6 +2960,8 @@
 
     "expo/@expo/config-plugins/semver": ["semver@7.7.2", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="],
 
+    "fbjs/cross-fetch/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
+
     "finalhandler/debug/ms": ["ms@2.0.0", "", {}, "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="],
 
     "glob/minimatch/brace-expansion": ["brace-expansion@1.1.12", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg=="],

docs/architecture-draft.md

@@ -16,8 +16,8 @@ Examples of feed items:
 ## Design Principles
 
 1. **Extensibility**: The core must support different data sources, including third-party sources.
-2. **Separation of concerns**: Core handles data and UI description. The client is a thin renderer.
+2. **Separation of concerns**: Core handles data only. UI rendering is a separate system.
-3. **Dependency graph**: Sources declare dependencies on other sources. The engine resolves the graph and runs independent sources in parallel.
+3. **Parallel execution**: Sources run in parallel; no inter-source dependencies.
 4. **Graceful degradation**: Failed sources are skipped; partial results are returned.
 
 ## Architecture
@@ -25,28 +25,26 @@ Examples of feed items:
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │                         Backend                              │
-│  ┌─────────────┐    ┌─────────────┐                         │
+│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────┐  │
-│  │  aris-core  │    │   Sources   │                         │
+│  │  aris-core  │    │   Sources   │    │  UI Registry    │  │
-│  │             │    │  (plugins)  │                         │
+│  │             │    │  (plugins)  │    │  (schemas from  │  │
-│  │ - FeedEngine│◄───│ - Calendar  │                         │
+│  │ - Reconciler│◄───│ - Calendar  │    │   third parties)│  │
-│  │ - Context   │    │ - Weather   │                         │
+│  │ - Context   │    │ - Weather   │    │                 │  │
-│  │ - FeedItem  │    │ - TfL       │                         │
+│  │ - FeedItem  │    │ - Spotify   │    │                 │  │
-│  │ - Actions   │    │ - Spotify   │                         │
+│  └─────────────┘    └─────────────┘    └─────────────────┘  │
-│  └─────────────┘    └─────────────┘                         │
+│         │                                      │             │
-│         │                                                    │
+│         ▼                                      ▼             │
-│         ▼                                                    │
+│    Feed (data only)                    UI Schemas (JSON)     │
-│    Feed items (data + ui trees + slots)                      │
 └─────────────────────────────────────────────────────────────┘
-                    │
+                    │                           │
-                    ▼ (WebSocket / JSON-RPC)
+                    ▼                           ▼
 ┌─────────────────────────────────────────────────────────────┐
-│                    Client (React Native)                      │
+│                        Frontend                              │
 │  ┌──────────────────────────────────────────────────────┐   │
-│  │  json-render + twrnc component map                    │   │
+│  │  Renderer                                             │   │
-│  │  - Receives feed items with ui trees                  │   │
+│  │  - Receives feed items                                │   │
-│  │  - Renders using registered RN components + twrnc     │   │
+│  │  - Fetches UI schema by item type                     │   │
-│  │  - User interactions trigger source actions           │   │
+│  │  - Renders using json-render or similar               │   │
-│  │  - Bespoke native components for rich interactions    │   │
 │  └──────────────────────────────────────────────────────┘   │
 └─────────────────────────────────────────────────────────────┘
 ```
@@ -56,16 +54,15 @@ Examples of feed items:
 The core is responsible for:
 
 - Defining the context and feed item interfaces
-- Providing a `FeedEngine` that orchestrates sources via a dependency graph
+- Providing a reconciler that orchestrates data sources
 - Returning a flat list of prioritized feed items
-- Routing action execution to the correct source
 
 ### Key Concepts
 
-- **Context**: Time and location (with accuracy) passed to all sources. Sources can contribute to context (e.g., location source provides coordinates, weather source provides conditions).
+- **Context**: Time and location (with accuracy) passed to all sources
-- **FeedItem**: Has an ID (source-generated, stable), type, timestamp, JSON-serializable data, optional actions, an optional `ui` tree, and optional `slots` for LLM-fillable content.
+- **FeedItem**: Has an ID (source-generated, stable), type, priority, timestamp, and JSON-serializable data
-- **FeedSource**: Interface that first and third parties implement to provide context, feed items, and actions. Uses reverse-domain IDs (e.g., `aris.weather`, `com.spotify`).
+- **DataSource**: Interface that third parties implement to provide feed items
-- **FeedEngine**: Orchestrates sources respecting their dependency graph, runs independent sources in parallel, returns items and any errors. Routes action execution to the correct source.
+- **Reconciler**: Orchestrates sources, runs them in parallel, returns items and any errors
 
 ## Data Sources
 
@@ -74,13 +71,10 @@ Key decisions:
 - Sources receive the full context and decide internally what to use
 - Each source returns a single item type (e.g., separate "Calendar Source" and "Location Suggestion Source" rather than a combined "Google Source")
 - Sources live in separate packages, not in the core
-- Sources declare dependencies on other sources (e.g., weather depends on location)
 - Sources are responsible for:
   - Transforming their domain data into feed items
   - Assigning priority based on domain logic (e.g., "event starting in 10 minutes" = high priority)
   - Returning empty arrays when nothing is relevant
-  - Providing a `ui` tree for each feed item
-  - Declaring and handling actions (e.g., RSVP, complete task, play/pause)
 
 ### Configuration
 
@@ -89,39 +83,26 @@ Configuration is passed at source registration time, not per reconcile call. Sou
 ## Feed Output
 
 - Flat list of `FeedItem` objects
-- Items carry data, an optional `ui` field describing their layout, and optional `slots` for LLM enhancement
+- No UI information (no icons, card types, etc.)
 - Items are a discriminated union by `type` field
+- Reconciler sorts by priority; can act as tiebreaker
 
-## UI Rendering: Server-Driven UI
+## UI Rendering (Separate from Core)
 
-The UI for feed items is **server-driven**. Sources describe how their items look using a JSON tree (the `ui` field on `FeedItem`). The client renders these trees using [json-render](https://json-render.dev/) with a registered set of React Native components styled via [twrnc](https://github.com/jaredh159/tailwind-react-native-classnames).
+The core does not handle UI. For extensible third-party UI:
 
-### How it works
+1. Third-party apps register their UI schemas through the backend (UI Registry)
+2. Frontend fetches UI schemas from the backend
+3. Frontend matches feed items to schemas by `type` and renders accordingly
 
-1. Sources return feed items with a `ui` field — a JSON tree describing the card layout using Tailwind class strings.
+This approach:
-2. The client passes a component map to json-render. Each component wraps a React Native primitive and resolves `className` via twrnc.
-3. json-render walks the tree and renders native components. twrnc parses Tailwind classes at runtime — no build step, arbitrary values work.
-4. User interactions (tap, etc.) map to source actions via the `actions` field on `FeedItem`. The client sends action requests to the backend, which routes them to the correct source via `FeedEngine.executeAction()`.
 
-### Styling
+- Keeps the core focused on data
+- Works across platforms (web, React Native)
+- Avoids the need for third parties to inject code into the app
+- Uses a json-render style approach for declarative UI from JSON schemas
 
-- Sources use Tailwind CSS class strings via the `className` prop (e.g., `"p-4 bg-white dark:bg-black rounded-xl"`).
+Reference: https://github.com/vercel-labs/json-render
-- twrnc resolves classes to React Native style objects at runtime. Supports arbitrary values (`mt-[31px]`, `bg-[#eaeaea]`), dark mode (`dark:bg-black`), and platform prefixes (`ios:pt-4 android:pt-2`).
-- Custom colors and spacing are configured via `tailwind.config.js` on the client.
-- No compile-time constraint — all styles resolve at runtime.
-
-### Two tiers of UI
-
-- **Server-driven (default):** Any source can return a `ui` tree. Covers most cards — weather, tasks, alerts, package tracking, news, etc. Simple interactions go through source actions. This is the default path for both first-party and third-party sources.
-- **Bespoke native:** For cards that need rich client interaction (gestures, animations, real-time updates), a native React Native component is registered in the json-render component map and referenced by type. Third parties that need this level of richness work with the ARIS team to get it integrated.
-
-### Why server-driven
-
-- Feed items are inherently server-driven — the data comes from sources on the backend. Attaching the layout alongside the data is a natural extension.
-- Card designs can be updated without shipping an app update.
-- Third-party sources can ship their own UI without bundling anything new into the app.
-
-Reference: https://json-render.dev/
 
 ## Feed Items with UI and Slots
 
@@ -403,9 +384,9 @@ function mergeEnhancement(
 
 ## Open Questions
 
-- How third parties authenticate/register their sources
+- Exact schema format for UI registry
-- Exact set of React Native components exposed in the json-render component map
+- How third parties authenticate/register their sources and UI schemas
-- Validation/sandboxing of third-party ui trees
+- JsonRenderNode type definition and component vocabulary
-- How synthetic items define their UI (full json-render tree vs. registered component)
+- How synthetic items define their UI (full json-render tree vs. registered schema)
 - Should slots support rich content (json-render nodes) in the future, or stay text-only?
 - How to handle slot content that references other items (e.g., "your dinner at The Ivy" linking to the calendar card)

docs/feed-source-actions-spec.md

@@ -125,7 +125,7 @@ interface FeedSource<TItem extends FeedItem = FeedItem> {
 
 ### Changes to FeedItem
 
-Optional fields added for actions, server-driven UI, and LLM slots.
+One optional field added.
 
 ```typescript
 interface FeedItem<
@@ -140,12 +140,6 @@ interface FeedItem<
 
 	/** Actions the user can take on this item. */
 	actions?: readonly ItemAction[]
-
-	/** Server-driven UI tree rendered by json-render on the client. */
-	ui?: JsonRenderNode
-
-	/** Named slots for LLM-fillable content. See architecture-draft.md. */
-	slots?: Record<string, Slot>
 }
 ```
 
@@ -228,25 +222,6 @@ class SpotifySource implements FeedSource<SpotifyFeedItem> {
 					{ actionId: "skip-track" },
 					{ actionId: "like-track", params: { trackId: track.id } },
 				],
-				ui: {
-					type: "View",
-					className: "flex-row items-center p-3 gap-3 bg-white dark:bg-black rounded-xl",
-					children: [
-						{
-							type: "Image",
-							source: { uri: track.albumArt },
-							className: "w-12 h-12 rounded-lg",
-						},
-						{
-							type: "View",
-							className: "flex-1",
-							children: [
-								{ type: "Text", className: "font-semibold text-black dark:text-white", text: track.name },
-								{ type: "Text", className: "text-sm text-gray-500 dark:text-gray-400", text: track.artist },
-							],
-						},
-					],
-				},
 			},
 		]
 	}
@@ -261,8 +236,6 @@ class SpotifySource implements FeedSource<SpotifyFeedItem> {
 4. `FeedSource.listActions()` is a required method returning `Record<string, ActionDefinition>` (empty record if no actions)
 5. `FeedSource.executeAction()` is a required method (no-op for sources without actions)
 6. `FeedItem.actions` is an optional readonly array of `ItemAction`
-6b. `FeedItem.ui` is an optional json-render tree describing server-driven UI
-6c. `FeedItem.slots` is an optional record of named LLM-fillable slots
 7. `FeedEngine.executeAction()` routes to correct source, returns `ActionResult`
 8. `FeedEngine.listActions()` aggregates actions from all sources
 9. Existing tests pass unchanged (all changes are additive)

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

@@ -18,9 +18,9 @@ import type { FeedItem } from "./feed"
  *     return [{
  *       id: `weather-${Date.now()}`,
  *       type: this.type,
+ *       priority: 0.5,
  *       timestamp: context.time,
  *       data: { temp: data.temperature },
- *       signals: { urgency: 0.5, timeRelevance: "ambient" },
  *     }]
  *   }
  * }

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

@@ -3,7 +3,7 @@ import { describe, expect, test } from "bun:test"
 import type { ActionDefinition, Context, ContextKey, FeedItem, FeedSource } from "./index"
 
 import { FeedEngine } from "./feed-engine"
-import { TimeRelevance, UnknownActionError, contextKey, contextValue } from "./index"
+import { UnknownActionError, contextKey, contextValue } from "./index"
 
 // No-op action methods for test sources
 const noActions = {
@@ -100,12 +100,12 @@ function createWeatherSource(
 				{
 					id: `weather-${Date.now()}`,
 					type: "weather",
+					priority: 0.5,
 					timestamp: new Date(),
 					data: {
 						temperature: weather.temperature,
 						condition: weather.condition,
 					},
-					signals: { urgency: 0.5, timeRelevance: TimeRelevance.Ambient },
 				},
 			]
 		},
@@ -131,9 +131,9 @@ function createAlertSource(): FeedSource<AlertFeedItem> {
 					{
 						id: "alert-storm",
 						type: "alert",
+						priority: 1.0,
 						timestamp: new Date(),
 						data: { message: "Storm warning!" },
-						signals: { urgency: 1.0, timeRelevance: TimeRelevance.Imminent },
 					},
 				]
 			}
@@ -322,7 +322,7 @@ describe("FeedEngine", () => {
 			expect(items[0]!.type).toBe("weather")
 		})
 
-		test("returns items in source graph order (no engine-level sorting)", async () => {
+		test("sorts items by priority descending", async () => {
 			const location = createLocationSource()
 			location.simulateUpdate({ lat: 51.5, lng: -0.1 })
 
@@ -338,12 +338,8 @@ describe("FeedEngine", () => {
 			const { items } = await engine.refresh()
 
 			expect(items).toHaveLength(2)
-			// Items returned in topological order (weather before alert)
+			expect(items[0]!.type).toBe("alert") // priority 1.0
-			expect(items[0]!.type).toBe("weather")
+			expect(items[1]!.type).toBe("weather") // priority 0.5
-			expect(items[1]!.type).toBe("alert")
-			// Signals are preserved for post-processors to consume
-			expect(items[0]!.signals?.urgency).toBe(0.5)
-			expect(items[1]!.signals?.urgency).toBe(1.0)
 		})
 
 		test("handles missing upstream context gracefully", async () => {

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

@@ -150,6 +150,9 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 			}
 		}
 
+		// Sort by priority descending
+		items.sort((a, b) => b.priority - a.priority)
+
 		this.context = context
 
 		const result: FeedResult<TItems> = { context, items: items as TItems[], errors }
@@ -311,6 +314,8 @@ export class FeedEngine<TItems extends FeedItem = FeedItem> {
 			}
 		}
 
+		items.sort((a, b) => b.priority - a.priority)
+
 		const result: FeedResult<TItems> = {
 			context: this.context,
 			items: items as TItems[],

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

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test"
 
 import type { ActionDefinition, Context, ContextKey, FeedItem, FeedSource } from "./index"
 
-import { TimeRelevance, UnknownActionError, contextKey, contextValue } from "./index"
+import { UnknownActionError, contextKey, contextValue } from "./index"
 
 // No-op action methods for test sources
 const noActions = {
@@ -99,12 +99,12 @@ function createWeatherSource(
 				{
 					id: `weather-${Date.now()}`,
 					type: "weather",
+					priority: 0.5,
 					timestamp: new Date(),
 					data: {
 						temperature: weather.temperature,
 						condition: weather.condition,
 					},
-					signals: { urgency: 0.5, timeRelevance: TimeRelevance.Ambient },
 				},
 			]
 		},
@@ -130,9 +130,9 @@ function createAlertSource(): FeedSource<AlertFeedItem> {
 					{
 						id: "alert-storm",
 						type: "alert",
+						priority: 1.0,
 						timestamp: new Date(),
 						data: { message: "Storm warning!" },
-						signals: { urgency: 1.0, timeRelevance: TimeRelevance.Imminent },
 					},
 				]
 			}
@@ -226,6 +226,9 @@ async function refreshGraph(graph: SourceGraph): Promise<{ context: Context; ite
 		}
 	}
 
+	// Sort by priority descending
+	items.sort((a, b) => b.priority - a.priority)
+
 	return { context, items }
 }
 
@@ -438,12 +441,8 @@ describe("FeedSource", () => {
 			const { items } = await refreshGraph(graph)
 
 			expect(items).toHaveLength(2)
-			// Items returned in topological order (weather before alert)
+			expect(items[0]!.type).toBe("alert") // priority 1.0
-			expect(items[0]!.type).toBe("weather")
+			expect(items[1]!.type).toBe("weather") // priority 0.5
-			expect(items[1]!.type).toBe("alert")
-			// Signals preserved for post-processors
-			expect(items[0]!.signals?.urgency).toBe(0.5)
-			expect(items[1]!.signals?.urgency).toBe(1.0)
 		})
 
 		test("source without location context returns empty items", async () => {

packages/aris-core/src/feed.ts

@@ -1,28 +1,3 @@
-/**
- * Source-provided hints for post-processors.
- *
- * Sources express domain-specific relevance without determining final ranking.
- * Post-processors consume these signals alongside other inputs (user affinity,
- * time of day, interaction history) to produce the final feed order.
- */
-export const TimeRelevance = {
-	/** Needs attention now (e.g., event starting in minutes, severe alert) */
-	Imminent: "imminent",
-	/** Relevant soon (e.g., event in the next hour, approaching deadline) */
-	Upcoming: "upcoming",
-	/** Background information (e.g., daily forecast, low-priority status) */
-	Ambient: "ambient",
-} as const
-
-export type TimeRelevance = (typeof TimeRelevance)[keyof typeof TimeRelevance]
-
-export interface FeedItemSignals {
-	/** Source-assessed urgency (0-1). Post-processors use this as one ranking input. */
-	urgency?: number
-	/** How time-sensitive this item is relative to now. */
-	timeRelevance?: TimeRelevance
-}
-
 /**
  * A single item in the feed.
  *
@@ -33,9 +8,9 @@ export interface FeedItemSignals {
  * const item: WeatherItem = {
  *   id: "weather-123",
  *   type: "weather",
+ *   priority: 0.5,
  *   timestamp: new Date(),
  *   data: { temp: 18, condition: "cloudy" },
- *   signals: { urgency: 0.5, timeRelevance: "ambient" },
  * }
  * ```
  */
@@ -47,10 +22,10 @@ export interface FeedItem<
 	id: string
 	/** Item type, matches the data source type */
 	type: TType
+	/** Sort priority (higher = more important, shown first) */
+	priority: number
 	/** When this item was generated */
 	timestamp: Date
 	/** Type-specific payload */
 	data: TData
-	/** Source-provided hints for post-processors. Optional — omit if no signals apply. */
-	signals?: FeedItemSignals
 }

packages/aris-core/src/index.ts

@@ -7,8 +7,7 @@ export type { ActionDefinition } from "./action"
 export { UnknownActionError } from "./action"
 
 // Feed
-export type { FeedItem, FeedItemSignals } from "./feed"
+export type { FeedItem } from "./feed"
-export { TimeRelevance } from "./feed"
 
 // Feed Source
 export type { FeedSource } from "./feed-source"

packages/aris-core/src/reconciler.ts

@@ -72,6 +72,8 @@ export class Reconciler<TItems extends FeedItem = never> {
 			}
 		})
 
+		items.sort((a, b) => b.priority - a.priority)
+
 		return { items, errors } as ReconcileResult<TItems>
 	}
 }

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

@@ -190,22 +190,21 @@ describe("query() with mocked client", () => {
 		expect(imperialTemp).toBeCloseTo(expectedImperial, 2)
 	})
 
-	test("assigns signals based on weather conditions", async () => {
+	test("assigns priority based on weather conditions", async () => {
 		const dataSource = new WeatherKitDataSource({ client: mockClient })
 		const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
 
 		const items = await dataSource.query(context)
 
 		for (const item of items) {
-			expect(item.signals).toBeDefined()
+			expect(item.priority).toBeGreaterThanOrEqual(0)
-			expect(item.signals!.urgency).toBeGreaterThanOrEqual(0)
+			expect(item.priority).toBeLessThanOrEqual(1)
-			expect(item.signals!.urgency).toBeLessThanOrEqual(1)
-			expect(item.signals!.timeRelevance).toBeDefined()
 		}
 
 		const currentItem = items.find((i) => i.type === WeatherFeedItemType.current)
 		expect(currentItem).toBeDefined()
-		expect(currentItem!.signals!.urgency).toBeGreaterThanOrEqual(0.5)
+		// Base priority for current is 0.5, may be adjusted for conditions
+		expect(currentItem!.priority).toBeGreaterThanOrEqual(0.5)
 	})
 
 	test("generates unique IDs for each item", async () => {

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

@@ -1,6 +1,4 @@
-import type { Context, DataSource, FeedItemSignals } from "@aris/core"
+import type { Context, DataSource } from "@aris/core"
-
-import { TimeRelevance } from "@aris/core"
 
 import {
 	WeatherFeedItemType,
@@ -107,7 +105,7 @@ export class WeatherKitDataSource implements DataSource<WeatherFeedItem, Weather
 	}
 }
 
-const BASE_URGENCY = {
+const BASE_PRIORITY = {
 	current: 0.5,
 	hourly: 0.3,
 	daily: 0.2,
@@ -136,17 +134,17 @@ const MODERATE_CONDITIONS = new Set<ConditionCode>([
 	ConditionCode.BlowingSnow,
 ])
 
-function adjustUrgencyForCondition(baseUrgency: number, conditionCode: ConditionCode): number {
+function adjustPriorityForCondition(basePriority: number, conditionCode: ConditionCode): number {
 	if (SEVERE_CONDITIONS.has(conditionCode)) {
-		return Math.min(1, baseUrgency + 0.3)
+		return Math.min(1, basePriority + 0.3)
 	}
 	if (MODERATE_CONDITIONS.has(conditionCode)) {
-		return Math.min(1, baseUrgency + 0.15)
+		return Math.min(1, basePriority + 0.15)
 	}
-	return baseUrgency
+	return basePriority
 }
 
-function adjustUrgencyForAlertSeverity(severity: Severity): number {
+function adjustPriorityForAlertSeverity(severity: Severity): number {
 	switch (severity) {
 		case Severity.Extreme:
 			return 1
@@ -155,29 +153,7 @@ function adjustUrgencyForAlertSeverity(severity: Severity): number {
 		case Severity.Moderate:
 			return 0.75
 		case Severity.Minor:
-			return BASE_URGENCY.alert
+			return BASE_PRIORITY.alert
-	}
-}
-
-function timeRelevanceForCondition(conditionCode: ConditionCode): TimeRelevance {
-	if (SEVERE_CONDITIONS.has(conditionCode)) {
-		return TimeRelevance.Imminent
-	}
-	if (MODERATE_CONDITIONS.has(conditionCode)) {
-		return TimeRelevance.Upcoming
-	}
-	return TimeRelevance.Ambient
-}
-
-function timeRelevanceForAlertSeverity(severity: Severity): TimeRelevance {
-	switch (severity) {
-		case Severity.Extreme:
-		case Severity.Severe:
-			return TimeRelevance.Imminent
-		case Severity.Moderate:
-			return TimeRelevance.Upcoming
-		case Severity.Minor:
-			return TimeRelevance.Ambient
 	}
 }
 
@@ -221,14 +197,12 @@ function createCurrentWeatherFeedItem(
 	timestamp: Date,
 	units: Units,
 ): CurrentWeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForCondition(BASE_PRIORITY.current, current.conditionCode)
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.current, current.conditionCode),
-		timeRelevance: timeRelevanceForCondition(current.conditionCode),
-	}
 
 	return {
 		id: `weather-current-${timestamp.getTime()}`,
 		type: WeatherFeedItemType.current,
+		priority,
 		timestamp,
 		data: {
 			conditionCode: current.conditionCode,
@@ -245,7 +219,6 @@ function createCurrentWeatherFeedItem(
 			windGust: convertSpeed(current.windGust, units),
 			windSpeed: convertSpeed(current.windSpeed, units),
 		},
-		signals,
 	}
 }
 
@@ -255,14 +228,12 @@ function createHourlyWeatherFeedItem(
 	timestamp: Date,
 	units: Units,
 ): HourlyWeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForCondition(BASE_PRIORITY.hourly, hourly.conditionCode)
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.hourly, hourly.conditionCode),
-		timeRelevance: timeRelevanceForCondition(hourly.conditionCode),
-	}
 
 	return {
 		id: `weather-hourly-${timestamp.getTime()}-${index}`,
 		type: WeatherFeedItemType.hourly,
+		priority,
 		timestamp,
 		data: {
 			forecastTime: new Date(hourly.forecastStart),
@@ -279,7 +250,6 @@ function createHourlyWeatherFeedItem(
 			windGust: convertSpeed(hourly.windGust, units),
 			windSpeed: convertSpeed(hourly.windSpeed, units),
 		},
-		signals,
 	}
 }
 
@@ -289,14 +259,12 @@ function createDailyWeatherFeedItem(
 	timestamp: Date,
 	units: Units,
 ): DailyWeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForCondition(BASE_PRIORITY.daily, daily.conditionCode)
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.daily, daily.conditionCode),
-		timeRelevance: timeRelevanceForCondition(daily.conditionCode),
-	}
 
 	return {
 		id: `weather-daily-${timestamp.getTime()}-${index}`,
 		type: WeatherFeedItemType.daily,
+		priority,
 		timestamp,
 		data: {
 			forecastDate: new Date(daily.forecastStart),
@@ -311,19 +279,16 @@ function createDailyWeatherFeedItem(
 			temperatureMax: convertTemperature(daily.temperatureMax, units),
 			temperatureMin: convertTemperature(daily.temperatureMin, units),
 		},
-		signals,
 	}
 }
 
 function createWeatherAlertFeedItem(alert: WeatherAlert, timestamp: Date): WeatherAlertFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForAlertSeverity(alert.severity)
-		urgency: adjustUrgencyForAlertSeverity(alert.severity),
-		timeRelevance: timeRelevanceForAlertSeverity(alert.severity),
-	}
 
 	return {
 		id: `weather-alert-${alert.id}`,
 		type: WeatherFeedItemType.alert,
+		priority,
 		timestamp,
 		data: {
 			alertId: alert.id,
@@ -337,6 +302,5 @@ function createWeatherAlertFeedItem(alert: WeatherAlert, timestamp: Date): Weath
 			source: alert.source,
 			urgency: alert.urgency,
 		},
-		signals,
 	}
 }

packages/aris-source-apple-calendar/fixtures/all-day-event.ics

@@ -0,0 +1,11 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:all-day-001@test
+DTSTART;VALUE=DATE:20260115
+DTEND;VALUE=DATE:20260116
+SUMMARY:Company Holiday
+STATUS:CONFIRMED
+END:VEVENT
+END:VCALENDAR

packages/aris-source-apple-calendar/fixtures/cancelled-event.ics

@@ -0,0 +1,11 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:cancelled-001@test
+DTSTART:20260115T120000Z
+DTEND:20260115T130000Z
+SUMMARY:Cancelled Meeting
+STATUS:CANCELLED
+END:VEVENT
+END:VCALENDAR

packages/aris-source-apple-calendar/fixtures/minimal-event.ics

@@ -0,0 +1,10 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:minimal-001@test
+DTSTART:20260115T180000Z
+DTEND:20260115T190000Z
+SUMMARY:Quick Chat
+END:VEVENT
+END:VCALENDAR

packages/aris-source-apple-calendar/fixtures/recurring-event.ics

@@ -0,0 +1,20 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:recurring-001@test
+DTSTART:20260115T090000Z
+DTEND:20260115T093000Z
+SUMMARY:Weekly Sync
+RRULE:FREQ=WEEKLY;COUNT=4
+STATUS:CONFIRMED
+END:VEVENT
+BEGIN:VEVENT
+UID:recurring-001@test
+RECURRENCE-ID:20260122T090000Z
+DTSTART:20260122T100000Z
+DTEND:20260122T103000Z
+SUMMARY:Weekly Sync (moved)
+STATUS:CONFIRMED
+END:VEVENT
+END:VCALENDAR

packages/aris-source-apple-calendar/fixtures/single-event.ics

@@ -0,0 +1,26 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Test//Test//EN
+BEGIN:VEVENT
+UID:single-event-001@test
+DTSTART:20260115T140000Z
+DTEND:20260115T150000Z
+SUMMARY:Team Standup
+LOCATION:Conference Room A
+DESCRIPTION:Daily standup meeting
+STATUS:CONFIRMED
+URL:https://example.com/meeting/123
+ORGANIZER;CN=Alice Smith:mailto:alice@example.com
+ATTENDEE;CN=Bob Jones;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED:mailto:bob@example.com
+ATTENDEE;CN=Carol White;ROLE=OPT-PARTICIPANT;PARTSTAT=TENTATIVE:mailto:carol@example.com
+BEGIN:VALARM
+TRIGGER:-PT15M
+ACTION:DISPLAY
+DESCRIPTION:Reminder
+END:VALARM
+BEGIN:VALARM
+TRIGGER:-PT5M
+ACTION:AUDIO
+END:VALARM
+END:VEVENT
+END:VCALENDAR

packages/aris-source-apple-calendar/package.json

@@ -0,0 +1,15 @@
+{
+	"name": "@aris/source-apple-calendar",
+	"version": "0.0.0",
+	"type": "module",
+	"main": "src/index.ts",
+	"types": "src/index.ts",
+	"scripts": {
+		"test": "bun test ."
+	},
+	"dependencies": {
+		"@aris/core": "workspace:*",
+		"ical.js": "^2.1.0",
+		"tsdav": "^2.1.7"
+	}
+}

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

@@ -0,0 +1,24 @@
+import type { ContextKey } from "@aris/core"
+
+import { contextKey } from "@aris/core"
+
+import type { CalendarEventData } from "./types.ts"
+
+/**
+ * Calendar context for downstream sources.
+ *
+ * Provides a snapshot of the user's upcoming events so other sources
+ * can adapt (e.g. a commute source checking if there's a meeting soon).
+ */
+export interface CalendarContext {
+	/** Events happening right now */
+	inProgress: CalendarEventData[]
+	/** Next upcoming event, if any */
+	nextEvent: CalendarEventData | null
+	/** Whether the user has any events today */
+	hasTodayEvents: boolean
+	/** Total number of events today */
+	todayEventCount: number
+}
+
+export const CalendarKey: ContextKey<CalendarContext> = contextKey("calendar")

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

@@ -0,0 +1,473 @@
+import type { Context } from "@aris/core"
+
+import { contextValue } from "@aris/core"
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import type {
+	CalendarCredentialProvider,
+	CalendarCredentials,
+	CalendarDAVCalendar,
+	CalendarDAVClient,
+	CalendarDAVObject,
+	CalendarEventData,
+} from "./types.ts"
+
+import { CalendarKey } from "./calendar-context.ts"
+import { CalendarSource, computePriority } from "./calendar-source.ts"
+
+function loadFixture(name: string): string {
+	return readFileSync(join(import.meta.dir, "..", "fixtures", name), "utf-8")
+}
+
+function createContext(time: Date): Context {
+	return { time }
+}
+
+const mockCredentials: CalendarCredentials = {
+	accessToken: "mock-access-token",
+	refreshToken: "mock-refresh-token",
+	expiresAt: Date.now() + 3600000,
+	tokenUrl: "https://appleid.apple.com/auth/token",
+	clientId: "com.example.aris",
+	clientSecret: "mock-secret",
+}
+
+class NullCredentialProvider implements CalendarCredentialProvider {
+	async fetchCredentials(_userId: string): Promise<CalendarCredentials | null> {
+		return null
+	}
+}
+
+class MockCredentialProvider implements CalendarCredentialProvider {
+	async fetchCredentials(_userId: string): Promise<CalendarCredentials | null> {
+		return mockCredentials
+	}
+}
+
+class MockDAVClient implements CalendarDAVClient {
+	credentials: Record<string, unknown> = {}
+	fetchCalendarsCallCount = 0
+	private calendars: CalendarDAVCalendar[]
+	private objectsByCalendarUrl: Record<string, CalendarDAVObject[]>
+
+	constructor(
+		calendars: CalendarDAVCalendar[],
+		objectsByCalendarUrl: Record<string, CalendarDAVObject[]>,
+	) {
+		this.calendars = calendars
+		this.objectsByCalendarUrl = objectsByCalendarUrl
+	}
+
+	async login(): Promise<void> {}
+
+	async fetchCalendars(): Promise<CalendarDAVCalendar[]> {
+		this.fetchCalendarsCallCount++
+		return this.calendars
+	}
+
+	async fetchCalendarObjects(params: {
+		calendar: CalendarDAVCalendar
+		timeRange: { start: string; end: string }
+	}): Promise<CalendarDAVObject[]> {
+		return this.objectsByCalendarUrl[params.calendar.url] ?? []
+	}
+}
+
+describe("CalendarSource", () => {
+	test("has correct id", () => {
+		const source = new CalendarSource(new NullCredentialProvider(), "user-1")
+		expect(source.id).toBe("aris.apple-calendar")
+	})
+
+	test("returns empty array when credentials are null", async () => {
+		const source = new CalendarSource(new NullCredentialProvider(), "user-1")
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+		expect(items).toEqual([])
+	})
+
+	test("returns empty array when no calendars exist", async () => {
+		const client = new MockDAVClient([], {})
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+		expect(items).toEqual([])
+	})
+
+	test("returns feed items from a single calendar", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") }],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+
+		expect(items).toHaveLength(1)
+		expect(items[0]!.type).toBe("calendar-event")
+		expect(items[0]!.id).toBe("calendar-event-single-event-001@test")
+		expect(items[0]!.data.title).toBe("Team Standup")
+		expect(items[0]!.data.location).toBe("Conference Room A")
+		expect(items[0]!.data.calendarName).toBe("Work")
+		expect(items[0]!.data.attendees).toHaveLength(2)
+		expect(items[0]!.data.alarms).toHaveLength(2)
+	})
+
+	test("returns feed items from multiple calendars", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") }],
+			"/cal/personal": [
+				{
+					url: "/cal/personal/event2.ics",
+					data: loadFixture("all-day-event.ics"),
+				},
+			],
+		}
+		const client = new MockDAVClient(
+			[
+				{ url: "/cal/work", displayName: "Work" },
+				{ url: "/cal/personal", displayName: "Personal" },
+			],
+			objects,
+		)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+
+		expect(items).toHaveLength(2)
+
+		const standup = items.find((i) => i.data.title === "Team Standup")
+		const holiday = items.find((i) => i.data.title === "Company Holiday")
+
+		expect(standup).toBeDefined()
+		expect(standup!.data.calendarName).toBe("Work")
+
+		expect(holiday).toBeDefined()
+		expect(holiday!.data.calendarName).toBe("Personal")
+		expect(holiday!.data.isAllDay).toBe(true)
+	})
+
+	test("skips objects with non-string data", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [
+				{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") },
+				{ url: "/cal/work/bad.ics", data: 12345 },
+				{ url: "/cal/work/empty.ics" },
+			],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+		expect(items).toHaveLength(1)
+		expect(items[0]!.data.title).toBe("Team Standup")
+	})
+
+	test("uses context time as feed item timestamp", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") }],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const now = new Date("2026-01-15T12:00:00Z")
+		const items = await source.fetchItems(createContext(now))
+		expect(items[0]!.timestamp).toEqual(now)
+	})
+
+	test("assigns priority based on event proximity", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [
+				{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") },
+				{ url: "/cal/work/allday.ics", data: loadFixture("all-day-event.ics") },
+			],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		// 2 hours before the event at 14:00
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+
+		const standup = items.find((i) => i.data.title === "Team Standup")
+		const holiday = items.find((i) => i.data.title === "Company Holiday")
+
+		expect(standup!.priority).toBe(0.7) // within 2 hours
+		expect(holiday!.priority).toBe(0.3) // all-day
+	})
+
+	test("handles calendar with non-string displayName", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/weird": [
+				{
+					url: "/cal/weird/event1.ics",
+					data: loadFixture("minimal-event.ics"),
+				},
+			],
+		}
+		const client = new MockDAVClient(
+			[{ url: "/cal/weird", displayName: { _cdata: "Weird Calendar" } }],
+			objects,
+		)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+		expect(items[0]!.data.calendarName).toBeNull()
+	})
+
+	test("handles recurring events with exceptions", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [
+				{
+					url: "/cal/work/recurring.ics",
+					data: loadFixture("recurring-event.ics"),
+				},
+			],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const items = await source.fetchItems(createContext(new Date("2026-01-15T08:00:00Z")))
+
+		expect(items).toHaveLength(2)
+
+		const base = items.find((i) => i.data.title === "Weekly Sync")
+		const exception = items.find((i) => i.data.title === "Weekly Sync (moved)")
+
+		expect(base).toBeDefined()
+		expect(base!.data.recurrenceId).toBeNull()
+
+		expect(exception).toBeDefined()
+		expect(exception!.data.recurrenceId).not.toBeNull()
+		expect(exception!.id).toContain("-")
+	})
+
+	test("caches events within the same refresh cycle", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") }],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const context = createContext(new Date("2026-01-15T12:00:00Z"))
+
+		await source.fetchContext(context)
+		await source.fetchItems(context)
+
+		// Same context.time reference — fetchEvents should only hit the client once
+		expect(client.fetchCalendarsCallCount).toBe(1)
+	})
+
+	test("refetches events for a different context time", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") }],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		await source.fetchItems(createContext(new Date("2026-01-15T12:00:00Z")))
+		await source.fetchItems(createContext(new Date("2026-01-15T13:00:00Z")))
+
+		// Different context.time references — should fetch twice
+		expect(client.fetchCalendarsCallCount).toBe(2)
+	})
+})
+
+describe("CalendarSource.fetchContext", () => {
+	test("returns empty context when credentials are null", async () => {
+		const source = new CalendarSource(new NullCredentialProvider(), "user-1")
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalendarKey)
+
+		expect(calendar).toBeDefined()
+		expect(calendar!.inProgress).toEqual([])
+		expect(calendar!.nextEvent).toBeNull()
+		expect(calendar!.hasTodayEvents).toBe(false)
+		expect(calendar!.todayEventCount).toBe(0)
+	})
+
+	test("identifies in-progress events", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") }],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		// 14:30 is during the 14:00-15:00 event
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T14:30:00Z")))
+		const calendar = contextValue(ctx as Context, CalendarKey)
+
+		expect(calendar!.inProgress).toHaveLength(1)
+		expect(calendar!.inProgress[0]!.title).toBe("Team Standup")
+	})
+
+	test("identifies next upcoming event", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") }],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		// 12:00 is before the 14:00 event
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalendarKey)
+
+		expect(calendar!.inProgress).toHaveLength(0)
+		expect(calendar!.nextEvent).not.toBeNull()
+		expect(calendar!.nextEvent!.title).toBe("Team Standup")
+	})
+
+	test("excludes all-day events from inProgress and nextEvent", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [{ url: "/cal/work/allday.ics", data: loadFixture("all-day-event.ics") }],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalendarKey)
+
+		expect(calendar!.inProgress).toHaveLength(0)
+		expect(calendar!.nextEvent).toBeNull()
+		expect(calendar!.hasTodayEvents).toBe(true)
+		expect(calendar!.todayEventCount).toBe(1)
+	})
+
+	test("counts all events including all-day in todayEventCount", async () => {
+		const objects: Record<string, CalendarDAVObject[]> = {
+			"/cal/work": [
+				{ url: "/cal/work/event1.ics", data: loadFixture("single-event.ics") },
+				{ url: "/cal/work/allday.ics", data: loadFixture("all-day-event.ics") },
+			],
+		}
+		const client = new MockDAVClient([{ url: "/cal/work", displayName: "Work" }], objects)
+		const source = new CalendarSource(new MockCredentialProvider(), "user-1", {
+			davClient: client,
+		})
+
+		const ctx = await source.fetchContext(createContext(new Date("2026-01-15T12:00:00Z")))
+		const calendar = contextValue(ctx as Context, CalendarKey)
+
+		expect(calendar!.todayEventCount).toBe(2)
+		expect(calendar!.hasTodayEvents).toBe(true)
+	})
+})
+
+describe("computePriority", () => {
+	const now = new Date("2026-01-15T12:00:00Z")
+
+	function makeEvent(overrides: Partial<CalendarEventData>): CalendarEventData {
+		return {
+			uid: "test-uid",
+			title: "Test",
+			startDate: new Date("2026-01-15T14:00:00Z"),
+			endDate: new Date("2026-01-15T15:00:00Z"),
+			isAllDay: false,
+			location: null,
+			description: null,
+			calendarName: null,
+			status: null,
+			url: null,
+			organizer: null,
+			attendees: [],
+			alarms: [],
+			recurrenceId: null,
+			...overrides,
+		}
+	}
+
+	test("all-day events get priority 0.3", () => {
+		const event = makeEvent({ isAllDay: true })
+		expect(computePriority(event, now)).toBe(0.3)
+	})
+
+	test("events starting within 30 minutes get priority 0.9", () => {
+		const event = makeEvent({
+			startDate: new Date("2026-01-15T12:20:00Z"),
+		})
+		expect(computePriority(event, now)).toBe(0.9)
+	})
+
+	test("events starting exactly at 30 minutes get priority 0.9", () => {
+		const event = makeEvent({
+			startDate: new Date("2026-01-15T12:30:00Z"),
+		})
+		expect(computePriority(event, now)).toBe(0.9)
+	})
+
+	test("events starting within 2 hours get priority 0.7", () => {
+		const event = makeEvent({
+			startDate: new Date("2026-01-15T13:00:00Z"),
+		})
+		expect(computePriority(event, now)).toBe(0.7)
+	})
+
+	test("events later today get priority 0.5", () => {
+		const event = makeEvent({
+			startDate: new Date("2026-01-15T20:00:00Z"),
+		})
+		expect(computePriority(event, now)).toBe(0.5)
+	})
+
+	test("in-progress events get priority 0.8", () => {
+		const event = makeEvent({
+			startDate: new Date("2026-01-15T11:00:00Z"),
+			endDate: new Date("2026-01-15T13:00:00Z"),
+		})
+		expect(computePriority(event, now)).toBe(0.8)
+	})
+
+	test("fully past events get priority 0.2", () => {
+		const event = makeEvent({
+			startDate: new Date("2026-01-15T09:00:00Z"),
+			endDate: new Date("2026-01-15T10:00:00Z"),
+		})
+		expect(computePriority(event, now)).toBe(0.2)
+	})
+
+	test("events on future days get priority 0.2", () => {
+		const event = makeEvent({
+			startDate: new Date("2026-01-16T10:00:00Z"),
+		})
+		expect(computePriority(event, now)).toBe(0.2)
+	})
+
+	test("priority boundaries are correct", () => {
+		// 31 minutes from now should be 0.7 (within 2 hours, not within 30 min)
+		const event31min = makeEvent({
+			startDate: new Date("2026-01-15T12:31:00Z"),
+		})
+		expect(computePriority(event31min, now)).toBe(0.7)
+
+		// 2 hours 1 minute from now should be 0.5 (later today, not within 2 hours)
+		const event2h1m = makeEvent({
+			startDate: new Date("2026-01-15T14:01:00Z"),
+		})
+		expect(computePriority(event2h1m, now)).toBe(0.5)
+	})
+})

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

@@ -0,0 +1,251 @@
+import type { ActionDefinition, Context, FeedSource } from "@aris/core"
+import { UnknownActionError } from "@aris/core"
+
+import { DAVClient } from "tsdav"
+
+import type {
+	CalendarCredentialProvider,
+	CalendarCredentials,
+	CalendarDAVClient,
+	CalendarEventData,
+	CalendarFeedItem,
+} from "./types.ts"
+
+export interface CalendarSourceOptions {
+	/** Number of additional days beyond today to fetch. Default: 0 (today only). */
+	lookAheadDays?: number
+	/** Optional DAVClient instance for testing. Uses tsdav DAVClient by default. */
+	davClient?: CalendarDAVClient
+}
+
+import { CalendarKey, type CalendarContext } from "./calendar-context.ts"
+import { parseICalEvents } from "./ical-parser.ts"
+
+const ICLOUD_CALDAV_URL = "https://caldav.icloud.com"
+const DEFAULT_LOOK_AHEAD_DAYS = 0
+
+/**
+ * A FeedSource that fetches Apple Calendar events via CalDAV.
+ *
+ * Credentials are provided by an injected CalendarCredentialProvider.
+ * The server is responsible for managing OAuth tokens and storage.
+ *
+ * @example
+ * ```ts
+ * const source = new CalendarSource(credentialProvider, "user-123")
+ * const engine = new FeedEngine()
+ * engine.register(source)
+ * ```
+ */
+export class CalendarSource implements FeedSource<CalendarFeedItem> {
+	readonly id = "aris.apple-calendar"
+
+	private readonly credentialProvider: CalendarCredentialProvider
+	private readonly userId: string
+	private readonly lookAheadDays: number
+	private readonly injectedClient: CalendarDAVClient | null
+	private davClient: CalendarDAVClient | null = null
+	private lastAccessToken: string | null = null
+	private cachedEvents: { time: Date; events: CalendarEventData[] } | null = null
+
+	constructor(
+		credentialProvider: CalendarCredentialProvider,
+		userId: string,
+		options?: CalendarSourceOptions,
+	) {
+		this.credentialProvider = credentialProvider
+		this.userId = userId
+		this.lookAheadDays = options?.lookAheadDays ?? DEFAULT_LOOK_AHEAD_DAYS
+		this.injectedClient = options?.davClient ?? null
+	}
+
+	async listActions(): Promise<Record<string, ActionDefinition>> {
+		return {}
+	}
+
+	async executeAction(actionId: string): Promise<void> {
+		throw new UnknownActionError(actionId)
+	}
+
+	async fetchContext(context: Context): Promise<Partial<Context> | null> {
+		const events = await this.fetchEvents(context)
+		if (events.length === 0) {
+			return {
+				[CalendarKey]: {
+					inProgress: [],
+					nextEvent: null,
+					hasTodayEvents: false,
+					todayEventCount: 0,
+				},
+			}
+		}
+
+		const now = context.time
+		const inProgress = events.filter((e) => !e.isAllDay && e.startDate <= now && e.endDate > now)
+
+		const upcoming = events
+			.filter((e) => !e.isAllDay && e.startDate > now)
+			.sort((a, b) => a.startDate.getTime() - b.startDate.getTime())
+
+		const calendarContext: CalendarContext = {
+			inProgress,
+			nextEvent: upcoming[0] ?? null,
+			hasTodayEvents: events.length > 0,
+			todayEventCount: events.length,
+		}
+
+		return { [CalendarKey]: calendarContext }
+	}
+
+	async fetchItems(context: Context): Promise<CalendarFeedItem[]> {
+		const now = context.time
+		const events = await this.fetchEvents(context)
+		return events.map((event) => createFeedItem(event, now))
+	}
+
+	private async fetchEvents(context: Context): Promise<CalendarEventData[]> {
+		if (this.cachedEvents && this.cachedEvents.time === context.time) {
+			return this.cachedEvents.events
+		}
+
+		const credentials = await this.credentialProvider.fetchCredentials(this.userId)
+		if (!credentials) {
+			return []
+		}
+
+		const client = await this.connectClient(credentials)
+		const calendars = await client.fetchCalendars()
+
+		const { start, end } = computeTimeRange(context.time, this.lookAheadDays)
+
+		const results = await Promise.allSettled(
+			calendars.map(async (calendar) => {
+				const objects = await client.fetchCalendarObjects({
+					calendar,
+					timeRange: {
+						start: start.toISOString(),
+						end: end.toISOString(),
+					},
+				})
+				// tsdav types displayName as string | Record<string, unknown> | undefined
+				// because the XML parser can return an object for some responses
+				const calendarName = typeof calendar.displayName === "string" ? calendar.displayName : null
+				return { objects, calendarName }
+			}),
+		)
+
+		const allEvents: CalendarEventData[] = []
+		for (const result of results) {
+			if (result.status !== "fulfilled") continue
+			const { objects, calendarName } = result.value
+			for (const obj of objects) {
+				if (typeof obj.data !== "string") continue
+
+				const events = parseICalEvents(obj.data, calendarName)
+				for (const event of events) {
+					allEvents.push(event)
+				}
+			}
+		}
+
+		this.cachedEvents = { time: context.time, events: allEvents }
+		return allEvents
+	}
+
+	/**
+	 * Returns a ready-to-use DAVClient. Creates and logs in a new client
+	 * on first call; reuses the existing one on subsequent calls, updating
+	 * credentials if the access token has changed.
+	 */
+	private async connectClient(credentials: CalendarCredentials): Promise<CalendarDAVClient> {
+		if (this.injectedClient) {
+			return this.injectedClient
+		}
+
+		const davCredentials = {
+			tokenUrl: credentials.tokenUrl,
+			refreshToken: credentials.refreshToken,
+			accessToken: credentials.accessToken,
+			expiration: credentials.expiresAt,
+			clientId: credentials.clientId,
+			clientSecret: credentials.clientSecret,
+		}
+
+		if (!this.davClient) {
+			this.davClient = new DAVClient({
+				serverUrl: ICLOUD_CALDAV_URL,
+				credentials: davCredentials,
+				authMethod: "Oauth",
+				defaultAccountType: "caldav",
+			})
+			await this.davClient.login()
+			this.lastAccessToken = credentials.accessToken
+			return this.davClient
+		}
+
+		if (credentials.accessToken !== this.lastAccessToken) {
+			this.davClient.credentials = davCredentials
+			this.lastAccessToken = credentials.accessToken
+		}
+
+		return this.davClient
+	}
+}
+
+function computeTimeRange(now: Date, lookAheadDays: number): { start: Date; end: Date } {
+	const start = new Date(now)
+	start.setUTCHours(0, 0, 0, 0)
+
+	const end = new Date(start)
+	end.setUTCDate(end.getUTCDate() + 1 + lookAheadDays)
+
+	return { start, end }
+}
+
+export function computePriority(event: CalendarEventData, now: Date): number {
+	if (event.isAllDay) {
+		return 0.3
+	}
+
+	const msUntilStart = event.startDate.getTime() - now.getTime()
+
+	// Event already started
+	if (msUntilStart < 0) {
+		const isInProgress = now.getTime() < event.endDate.getTime()
+		// Currently happening events are high priority; fully past events are low
+		return isInProgress ? 0.8 : 0.2
+	}
+
+	// Starting within 30 minutes
+	if (msUntilStart <= 30 * 60 * 1000) {
+		return 0.9
+	}
+
+	// Starting within 2 hours
+	if (msUntilStart <= 2 * 60 * 60 * 1000) {
+		return 0.7
+	}
+
+	// Later today (within 24 hours from start of day)
+	const startOfDay = new Date(now)
+	startOfDay.setUTCHours(0, 0, 0, 0)
+	const endOfDay = new Date(startOfDay)
+	endOfDay.setUTCDate(endOfDay.getUTCDate() + 1)
+
+	if (event.startDate.getTime() < endOfDay.getTime()) {
+		return 0.5
+	}
+
+	// Future days
+	return 0.2
+}
+
+function createFeedItem(event: CalendarEventData, now: Date): CalendarFeedItem {
+	return {
+		id: `calendar-event-${event.uid}${event.recurrenceId ? `-${event.recurrenceId}` : ""}`,
+		type: "calendar-event",
+		priority: computePriority(event, now),
+		timestamp: now,
+		data: event,
+	}
+}

packages/aris-source-apple-calendar/src/ical-parser.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { parseICalEvents } from "./ical-parser.ts"
+
+function loadFixture(name: string): string {
+	return readFileSync(join(import.meta.dir, "..", "fixtures", name), "utf-8")
+}
+
+describe("parseICalEvents", () => {
+	test("parses a full event with all fields", () => {
+		const events = parseICalEvents(loadFixture("single-event.ics"), "Work")
+
+		expect(events).toHaveLength(1)
+		const event = events[0]!
+
+		expect(event.uid).toBe("single-event-001@test")
+		expect(event.title).toBe("Team Standup")
+		expect(event.startDate).toEqual(new Date("2026-01-15T14:00:00Z"))
+		expect(event.endDate).toEqual(new Date("2026-01-15T15:00:00Z"))
+		expect(event.isAllDay).toBe(false)
+		expect(event.location).toBe("Conference Room A")
+		expect(event.description).toBe("Daily standup meeting")
+		expect(event.calendarName).toBe("Work")
+		expect(event.status).toBe("confirmed")
+		expect(event.url).toBe("https://example.com/meeting/123")
+		expect(event.organizer).toBe("Alice Smith")
+		expect(event.recurrenceId).toBeNull()
+
+		expect(event.attendees).toHaveLength(2)
+		expect(event.attendees[0]).toEqual({
+			name: "Bob Jones",
+			email: "bob@example.com",
+			role: "required",
+			status: "accepted",
+		})
+		expect(event.attendees[1]).toEqual({
+			name: "Carol White",
+			email: "carol@example.com",
+			role: "optional",
+			status: "tentative",
+		})
+
+		expect(event.alarms).toHaveLength(2)
+		expect(event.alarms[0]).toEqual({ trigger: "-PT15M", action: "DISPLAY" })
+		expect(event.alarms[1]).toEqual({ trigger: "-PT5M", action: "AUDIO" })
+	})
+
+	test("parses an all-day event with optional fields as null", () => {
+		const events = parseICalEvents(loadFixture("all-day-event.ics"), null)
+
+		expect(events).toHaveLength(1)
+		const event = events[0]!
+
+		expect(event.isAllDay).toBe(true)
+		expect(event.title).toBe("Company Holiday")
+		expect(event.calendarName).toBeNull()
+		expect(event.location).toBeNull()
+		expect(event.description).toBeNull()
+		expect(event.url).toBeNull()
+		expect(event.organizer).toBeNull()
+		expect(event.attendees).toEqual([])
+		expect(event.alarms).toEqual([])
+	})
+
+	test("parses recurring event with exception", () => {
+		const events = parseICalEvents(loadFixture("recurring-event.ics"), "Team")
+
+		expect(events).toHaveLength(2)
+		expect(events[0]!.uid).toBe("recurring-001@test")
+		expect(events[1]!.uid).toBe("recurring-001@test")
+
+		const base = events.find((e) => e.title === "Weekly Sync")
+		expect(base).toBeDefined()
+		expect(base!.recurrenceId).toBeNull()
+
+		const exception = events.find((e) => e.title === "Weekly Sync (moved)")
+		expect(exception).toBeDefined()
+		expect(exception!.recurrenceId).not.toBeNull()
+	})
+
+	test("parses minimal event with defaults", () => {
+		const events = parseICalEvents(loadFixture("minimal-event.ics"), null)
+
+		expect(events).toHaveLength(1)
+		const event = events[0]!
+
+		expect(event.uid).toBe("minimal-001@test")
+		expect(event.title).toBe("Quick Chat")
+		expect(event.startDate).toEqual(new Date("2026-01-15T18:00:00Z"))
+		expect(event.endDate).toEqual(new Date("2026-01-15T19:00:00Z"))
+		expect(event.location).toBeNull()
+		expect(event.description).toBeNull()
+		expect(event.status).toBeNull()
+		expect(event.url).toBeNull()
+		expect(event.organizer).toBeNull()
+		expect(event.attendees).toEqual([])
+		expect(event.alarms).toEqual([])
+		expect(event.recurrenceId).toBeNull()
+	})
+
+	test("parses cancelled status", () => {
+		const events = parseICalEvents(loadFixture("cancelled-event.ics"), null)
+		expect(events[0]!.status).toBe("cancelled")
+	})
+})

packages/aris-source-apple-calendar/src/ical-parser.ts

@@ -0,0 +1,150 @@
+import ICAL from "ical.js"
+
+import {
+	AttendeeRole,
+	AttendeeStatus,
+	CalendarEventStatus,
+	type CalendarAlarm,
+	type CalendarAttendee,
+	type CalendarEventData,
+} from "./types.ts"
+
+/**
+ * Parses a raw iCalendar string and extracts all VEVENT components
+ * into CalendarEventData objects.
+ *
+ * @param icsData - Raw iCalendar string from a CalDAV response
+ * @param calendarName - Display name of the calendar this event belongs to
+ */
+export function parseICalEvents(icsData: string, calendarName: string | null): CalendarEventData[] {
+	const jcal = ICAL.parse(icsData)
+	const comp = new ICAL.Component(jcal)
+	const vevents = comp.getAllSubcomponents("vevent")
+
+	return vevents.map((vevent: InstanceType<typeof ICAL.Component>) =>
+		parseVEvent(vevent, calendarName),
+	)
+}
+
+function parseVEvent(
+	vevent: InstanceType<typeof ICAL.Component>,
+	calendarName: string | null,
+): CalendarEventData {
+	const event = new ICAL.Event(vevent)
+
+	return {
+		uid: event.uid ?? "",
+		title: event.summary ?? "",
+		startDate: event.startDate?.toJSDate() ?? new Date(0),
+		endDate: event.endDate?.toJSDate() ?? new Date(0),
+		isAllDay: event.startDate?.isDate ?? false,
+		location: event.location ?? null,
+		description: event.description ?? null,
+		calendarName,
+		status: parseStatus(asStringOrNull(vevent.getFirstPropertyValue("status"))),
+		url: asStringOrNull(vevent.getFirstPropertyValue("url")),
+		organizer: parseOrganizer(asStringOrNull(event.organizer), vevent),
+		attendees: parseAttendees(Array.isArray(event.attendees) ? event.attendees : []),
+		alarms: parseAlarms(vevent),
+		recurrenceId: event.recurrenceId ? event.recurrenceId.toString() : null,
+	}
+}
+
+function parseStatus(raw: string | null): CalendarEventStatus | null {
+	if (!raw) return null
+	switch (raw.toLowerCase()) {
+		case "confirmed":
+			return CalendarEventStatus.Confirmed
+		case "tentative":
+			return CalendarEventStatus.Tentative
+		case "cancelled":
+			return CalendarEventStatus.Cancelled
+		default:
+			return null
+	}
+}
+
+function parseOrganizer(
+	value: string | null,
+	vevent: InstanceType<typeof ICAL.Component>,
+): string | null {
+	if (!value) return null
+
+	// Try CN parameter first
+	const prop = vevent.getFirstProperty("organizer")
+	if (prop) {
+		const cn = prop.getParameter("cn") as string | undefined
+		if (cn) return cn
+	}
+
+	// Fall back to mailto: value
+	return value.replace(/^mailto:/i, "")
+}
+
+function parseAttendees(properties: unknown[]): CalendarAttendee[] {
+	if (properties.length === 0) return []
+
+	return properties.map((prop) => {
+		const p = prop as InstanceType<typeof ICAL.Property>
+		const value = asStringOrNull(p.getFirstValue())
+		const cn = asStringOrNull(p.getParameter("cn"))
+		const role = asStringOrNull(p.getParameter("role"))
+		const partstat = asStringOrNull(p.getParameter("partstat"))
+
+		return {
+			name: cn,
+			email: value ? value.replace(/^mailto:/i, "") : null,
+			role: parseAttendeeRole(role),
+			status: parseAttendeeStatus(partstat),
+		}
+	})
+}
+
+function parseAttendeeRole(raw: string | null): AttendeeRole | null {
+	if (!raw) return null
+	switch (raw.toUpperCase()) {
+		case "CHAIR":
+			return AttendeeRole.Chair
+		case "REQ-PARTICIPANT":
+			return AttendeeRole.Required
+		case "OPT-PARTICIPANT":
+			return AttendeeRole.Optional
+		default:
+			return null
+	}
+}
+
+function parseAttendeeStatus(raw: string | null): AttendeeStatus | null {
+	if (!raw) return null
+	switch (raw.toUpperCase()) {
+		case "ACCEPTED":
+			return AttendeeStatus.Accepted
+		case "DECLINED":
+			return AttendeeStatus.Declined
+		case "TENTATIVE":
+			return AttendeeStatus.Tentative
+		case "NEEDS-ACTION":
+			return AttendeeStatus.NeedsAction
+		default:
+			return null
+	}
+}
+
+function parseAlarms(vevent: InstanceType<typeof ICAL.Component>): CalendarAlarm[] {
+	const valarms = vevent.getAllSubcomponents("valarm")
+	if (!valarms || valarms.length === 0) return []
+
+	return valarms.map((valarm: InstanceType<typeof ICAL.Component>) => {
+		const trigger = valarm.getFirstPropertyValue("trigger")
+		const action = asStringOrNull(valarm.getFirstPropertyValue("action"))
+
+		return {
+			trigger: trigger ? trigger.toString() : "",
+			action: action ?? "DISPLAY",
+		}
+	})
+}
+
+function asStringOrNull(value: unknown): string | null {
+	return typeof value === "string" ? value : null
+}

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

@@ -0,0 +1,16 @@
+export { CalendarKey, type CalendarContext } from "./calendar-context.ts"
+export { CalendarSource, type CalendarSourceOptions } from "./calendar-source.ts"
+export {
+	CalendarEventStatus,
+	AttendeeRole,
+	AttendeeStatus,
+	type CalendarCredentials,
+	type CalendarCredentialProvider,
+	type CalendarDAVClient,
+	type CalendarDAVCalendar,
+	type CalendarDAVObject,
+	type CalendarAttendee,
+	type CalendarAlarm,
+	type CalendarEventData,
+	type CalendarFeedItem,
+} from "./types.ts"

packages/aris-source-apple-calendar/src/types.ts

@@ -0,0 +1,101 @@
+import type { FeedItem } from "@aris/core"
+
+// -- Credential provider --
+
+export interface CalendarCredentials {
+	accessToken: string
+	refreshToken: string
+	/** Unix timestamp in milliseconds when the access token expires */
+	expiresAt: number
+	tokenUrl: string
+	clientId: string
+	clientSecret: string
+}
+
+export interface CalendarCredentialProvider {
+	fetchCredentials(userId: string): Promise<CalendarCredentials | null>
+}
+
+// -- Feed item types --
+
+export const CalendarEventStatus = {
+	Confirmed: "confirmed",
+	Tentative: "tentative",
+	Cancelled: "cancelled",
+} as const
+
+export type CalendarEventStatus = (typeof CalendarEventStatus)[keyof typeof CalendarEventStatus]
+
+export const AttendeeRole = {
+	Chair: "chair",
+	Required: "required",
+	Optional: "optional",
+} as const
+
+export type AttendeeRole = (typeof AttendeeRole)[keyof typeof AttendeeRole]
+
+export const AttendeeStatus = {
+	Accepted: "accepted",
+	Declined: "declined",
+	Tentative: "tentative",
+	NeedsAction: "needs-action",
+} as const
+
+export type AttendeeStatus = (typeof AttendeeStatus)[keyof typeof AttendeeStatus]
+
+export interface CalendarAttendee {
+	name: string | null
+	email: string | null
+	role: AttendeeRole | null
+	status: AttendeeStatus | null
+}
+
+export interface CalendarAlarm {
+	/** ISO 8601 duration relative to event start, e.g. "-PT15M" */
+	trigger: string
+	/** e.g. "DISPLAY", "AUDIO" */
+	action: string
+}
+
+export interface CalendarEventData extends Record<string, unknown> {
+	uid: string
+	title: string
+	startDate: Date
+	endDate: Date
+	isAllDay: boolean
+	location: string | null
+	description: string | null
+	calendarName: string | null
+	status: CalendarEventStatus | null
+	url: string | null
+	organizer: string | null
+	attendees: CalendarAttendee[]
+	alarms: CalendarAlarm[]
+	recurrenceId: string | null
+}
+
+export type CalendarFeedItem = FeedItem<"calendar-event", CalendarEventData>
+
+// -- DAV client interface --
+
+export interface CalendarDAVObject {
+	data?: unknown
+	etag?: string
+	url: string
+}
+
+export interface CalendarDAVCalendar {
+	displayName?: string | Record<string, unknown>
+	url: string
+}
+
+/** Subset of DAVClient used by CalendarSource. */
+export interface CalendarDAVClient {
+	login(): Promise<void>
+	fetchCalendars(): Promise<CalendarDAVCalendar[]>
+	fetchCalendarObjects(params: {
+		calendar: CalendarDAVCalendar
+		timeRange: { start: string; end: string }
+	}): Promise<CalendarDAVObject[]>
+	credentials: Record<string, unknown>
+}

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

@@ -1,4 +1,4 @@
-import { TimeRelevance, contextValue, type Context } from "@aris/core"
+import { contextValue, type Context } from "@aris/core"
 import { describe, expect, test } from "bun:test"
 
 import type { ApiCalendarEvent, GoogleCalendarClient, ListEventsOptions } from "./types"
@@ -81,17 +81,16 @@ describe("GoogleCalendarSource", () => {
 			expect(allDayItems.length).toBe(1)
 		})
 
-		test("ongoing events get highest urgency (1.0)", async () => {
+		test("ongoing events get highest priority (1.0)", async () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
 			const items = await source.fetchItems(createContext())
 
 			const ongoing = items.find((i) => i.data.eventId === "evt-ongoing")
 			expect(ongoing).toBeDefined()
-			expect(ongoing!.signals!.urgency).toBe(1.0)
+			expect(ongoing!.priority).toBe(1.0)
-			expect(ongoing!.signals!.timeRelevance).toBe(TimeRelevance.Imminent)
 		})
 
-		test("upcoming events get higher urgency when sooner", async () => {
+		test("upcoming events get higher priority when sooner", async () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
 			const items = await source.fetchItems(createContext())
 
@@ -100,17 +99,16 @@ describe("GoogleCalendarSource", () => {
 
 			expect(soon).toBeDefined()
 			expect(later).toBeDefined()
-			expect(soon!.signals!.urgency).toBeGreaterThan(later!.signals!.urgency!)
+			expect(soon!.priority).toBeGreaterThan(later!.priority)
 		})
 
-		test("all-day events get flat urgency (0.4)", async () => {
+		test("all-day events get flat priority (0.4)", async () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
 			const items = await source.fetchItems(createContext())
 
 			const allDay = items.find((i) => i.data.eventId === "evt-allday")
 			expect(allDay).toBeDefined()
-			expect(allDay!.signals!.urgency).toBe(0.4)
+			expect(allDay!.priority).toBe(0.4)
-			expect(allDay!.signals!.timeRelevance).toBe(TimeRelevance.Ambient)
 		})
 
 		test("generates unique IDs for each item", async () => {
@@ -282,7 +280,7 @@ describe("GoogleCalendarSource", () => {
 		})
 	})
 
-	describe("urgency ordering", () => {
+	describe("priority ordering", () => {
 		test("ongoing > upcoming > all-day", async () => {
 			const source = new GoogleCalendarSource({ client: defaultMockClient() })
 			const items = await source.fetchItems(createContext())
@@ -291,8 +289,8 @@ describe("GoogleCalendarSource", () => {
 			const upcoming = items.find((i) => i.data.eventId === "evt-soon")!
 			const allDay = items.find((i) => i.data.eventId === "evt-allday")!
 
-			expect(ongoing.signals!.urgency).toBeGreaterThan(upcoming.signals!.urgency!)
+			expect(ongoing.priority).toBeGreaterThan(upcoming.priority)
-			expect(upcoming.signals!.urgency).toBeGreaterThan(allDay.signals!.urgency!)
+			expect(upcoming.priority).toBeGreaterThan(allDay.priority)
 		})
 	})
 })

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

@@ -1,6 +1,6 @@
-import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedSource } from "@aris/core"
 
-import { TimeRelevance, UnknownActionError } from "@aris/core"
+import { UnknownActionError } from "@aris/core"
 
 import type {
 	ApiCalendarEvent,
@@ -35,10 +35,10 @@ import { DefaultGoogleCalendarClient } from "./google-calendar-api"
 
 const DEFAULT_LOOKAHEAD_HOURS = 24
 
-const URGENCY_ONGOING = 1.0
+const PRIORITY_ONGOING = 1.0
-const URGENCY_UPCOMING_MAX = 0.9
+const PRIORITY_UPCOMING_MAX = 0.9
-const URGENCY_UPCOMING_MIN = 0.3
+const PRIORITY_UPCOMING_MIN = 0.3
-const URGENCY_ALL_DAY = 0.4
+const PRIORITY_ALL_DAY = 0.4
 
 /**
  * A FeedSource that provides Google Calendar events and next-event context.
@@ -171,13 +171,9 @@ function parseEvent(event: ApiCalendarEvent, calendarId: string): CalendarEventD
 	}
 }
 
-function computeSignals(
+function computePriority(event: CalendarEventData, nowMs: number, lookaheadMs: number): number {
-	event: CalendarEventData,
-	nowMs: number,
-	lookaheadMs: number,
-): FeedItemSignals {
 	if (event.isAllDay) {
-		return { urgency: URGENCY_ALL_DAY, timeRelevance: TimeRelevance.Ambient }
+		return PRIORITY_ALL_DAY
 	}
 
 	const startMs = event.startTime.getTime()
@@ -185,23 +181,17 @@ function computeSignals(
 
 	// Ongoing: start <= now < end
 	if (startMs <= nowMs && nowMs < endMs) {
-		return { urgency: URGENCY_ONGOING, timeRelevance: TimeRelevance.Imminent }
+		return PRIORITY_ONGOING
 	}
 
-	// Upcoming: linear decay from URGENCY_UPCOMING_MAX to URGENCY_UPCOMING_MIN
+	// Upcoming: linear decay from PRIORITY_UPCOMING_MAX to PRIORITY_UPCOMING_MIN
 	const msUntilStart = startMs - nowMs
 	if (msUntilStart <= 0) {
-		return { urgency: URGENCY_UPCOMING_MIN, timeRelevance: TimeRelevance.Ambient }
+		return PRIORITY_UPCOMING_MIN
 	}
 
 	const ratio = Math.min(msUntilStart / lookaheadMs, 1)
-	const urgency = URGENCY_UPCOMING_MAX - ratio * (URGENCY_UPCOMING_MAX - URGENCY_UPCOMING_MIN)
+	return PRIORITY_UPCOMING_MAX - ratio * (PRIORITY_UPCOMING_MAX - PRIORITY_UPCOMING_MIN)
-
-	// Within 30 minutes = imminent, otherwise upcoming
-	const timeRelevance =
-		msUntilStart <= 30 * 60 * 1000 ? TimeRelevance.Imminent : TimeRelevance.Upcoming
-
-	return { urgency, timeRelevance }
 }
 
 function createFeedItem(
@@ -209,13 +199,14 @@ function createFeedItem(
 	nowMs: number,
 	lookaheadMs: number,
 ): CalendarFeedItem {
+	const priority = computePriority(event, nowMs, lookaheadMs)
 	const itemType = event.isAllDay ? CalendarFeedItemType.allDay : CalendarFeedItemType.event
 
 	return {
 		id: `calendar-${event.calendarId}-${event.eventId}`,
 		type: itemType,
+		priority,
 		timestamp: new Date(nowMs),
 		data: event,
-		signals: computeSignals(event, nowMs, lookaheadMs),
 	}
 }

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

@@ -184,8 +184,7 @@ describe("TflSource", () => {
 				expect(typeof item.id).toBe("string")
 				expect(item.id).toMatch(/^tfl-alert-/)
 				expect(item.type).toBe("tfl-alert")
-				expect(item.signals).toBeDefined()
+				expect(typeof item.priority).toBe("number")
-				expect(typeof item.signals!.urgency).toBe("number")
 				expect(item.timestamp).toBeInstanceOf(Date)
 			}
 		})
@@ -221,29 +220,29 @@ describe("TflSource", () => {
 			expect(uniqueIds.size).toBe(ids.length)
 		})
 
-		test("feed items are sorted by urgency descending", async () => {
+		test("feed items are sorted by priority descending", async () => {
 			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
 
 			for (let i = 1; i < items.length; i++) {
 				const prev = items[i - 1]!
 				const curr = items[i]!
-				expect(prev.signals!.urgency).toBeGreaterThanOrEqual(curr.signals!.urgency!)
+				expect(prev.priority).toBeGreaterThanOrEqual(curr.priority)
 			}
 		})
 
-		test("urgency values match severity levels", async () => {
+		test("priority values match severity levels", async () => {
 			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
 
-			const severityUrgency: Record<string, number> = {
+			const severityPriority: Record<string, number> = {
 				closure: 1.0,
 				"major-delays": 0.8,
 				"minor-delays": 0.6,
 			}
 
 			for (const item of items) {
-				expect(item.signals!.urgency).toBe(severityUrgency[item.data.severity]!)
+				expect(item.priority).toBe(severityPriority[item.data.severity]!)
 			}
 		})
 
@@ -317,7 +316,9 @@ describe("TflSource", () => {
 		test("executeAction throws on invalid input", async () => {
 			const source = new TflSource({ client: api })
 
-			await expect(source.executeAction("set-lines-of-interest", "not-an-array")).rejects.toThrow()
+			await expect(
+				source.executeAction("set-lines-of-interest", "not-an-array"),
+			).rejects.toThrow()
 		})
 
 		test("executeAction throws for unknown action", async () => {

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

@@ -1,6 +1,6 @@
-import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedSource } from "@aris/core"
 
-import { TimeRelevance, UnknownActionError, contextValue } from "@aris/core"
+import { UnknownActionError, contextValue } from "@aris/core"
 import { LocationKey } from "@aris/source-location"
 import { type } from "arktype"
 
@@ -18,18 +18,12 @@ import { TflApi, lineId } from "./tfl-api.ts"
 
 const setLinesInput = lineId.array()
 
-const SEVERITY_URGENCY: Record<TflAlertSeverity, number> = {
+const SEVERITY_PRIORITY: Record<TflAlertSeverity, number> = {
 	closure: 1.0,
 	"major-delays": 0.8,
 	"minor-delays": 0.6,
 }
 
-const SEVERITY_TIME_RELEVANCE: Record<TflAlertSeverity, TimeRelevance> = {
-	closure: TimeRelevance.Imminent,
-	"major-delays": TimeRelevance.Imminent,
-	"minor-delays": TimeRelevance.Upcoming,
-}
-
 /**
  * A FeedSource that provides TfL (Transport for London) service alerts.
  *
@@ -143,26 +137,19 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 				closestStationDistance,
 			}
 
-			const signals: FeedItemSignals = {
-				urgency: SEVERITY_URGENCY[status.severity],
-				timeRelevance: SEVERITY_TIME_RELEVANCE[status.severity],
-			}
-
 			return {
 				id: `tfl-alert-${status.lineId}-${status.severity}`,
 				type: "tfl-alert",
+				priority: SEVERITY_PRIORITY[status.severity],
 				timestamp: context.time,
 				data,
-				signals,
 			}
 		})
 
-		// Sort by urgency (desc), then by proximity (asc) if location available
+		// Sort by severity (desc), then by proximity (asc) if location available
 		items.sort((a, b) => {
-			const aUrgency = a.signals?.urgency ?? 0
+			if (b.priority !== a.priority) {
-			const bUrgency = b.signals?.urgency ?? 0
+				return b.priority - a.priority
-			if (bUrgency !== aUrgency) {
-				return bUrgency - aUrgency
 			}
 			if (a.data.closestStationDistance !== null && b.data.closestStationDistance !== null) {
 				return a.data.closestStationDistance - b.data.closestStationDistance

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

@@ -145,22 +145,20 @@ describe("WeatherSource", () => {
 			}
 		})
 
-		test("assigns signals based on weather conditions", async () => {
+		test("assigns priority based on weather conditions", async () => {
 			const source = new WeatherSource({ client: mockClient })
 			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
 
 			const items = await source.fetchItems(context)
 
 			for (const item of items) {
-				expect(item.signals).toBeDefined()
+				expect(item.priority).toBeGreaterThanOrEqual(0)
-				expect(item.signals!.urgency).toBeGreaterThanOrEqual(0)
+				expect(item.priority).toBeLessThanOrEqual(1)
-				expect(item.signals!.urgency).toBeLessThanOrEqual(1)
-				expect(item.signals!.timeRelevance).toBeDefined()
 			}
 
 			const currentItem = items.find((i) => i.type === WeatherFeedItemType.current)
 			expect(currentItem).toBeDefined()
-			expect(currentItem!.signals!.urgency).toBeGreaterThanOrEqual(0.5)
+			expect(currentItem!.priority).toBeGreaterThanOrEqual(0.5)
 		})
 
 		test("generates unique IDs for each item", async () => {

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

@@ -1,6 +1,6 @@
-import type { ActionDefinition, Context, FeedItemSignals, FeedSource } from "@aris/core"
+import type { ActionDefinition, Context, FeedSource } from "@aris/core"
 
-import { TimeRelevance, UnknownActionError, contextValue } from "@aris/core"
+import { UnknownActionError, contextValue } from "@aris/core"
 import { LocationKey } from "@aris/source-location"
 
 import { WeatherFeedItemType, type WeatherFeedItem } from "./feed-items"
@@ -38,7 +38,7 @@ export interface WeatherSourceOptions {
 const DEFAULT_HOURLY_LIMIT = 12
 const DEFAULT_DAILY_LIMIT = 7
 
-const BASE_URGENCY = {
+const BASE_PRIORITY = {
 	current: 0.5,
 	hourly: 0.3,
 	daily: 0.2,
@@ -199,17 +199,17 @@ export class WeatherSource implements FeedSource<WeatherFeedItem> {
 	}
 }
 
-function adjustUrgencyForCondition(baseUrgency: number, conditionCode: ConditionCode): number {
+function adjustPriorityForCondition(basePriority: number, conditionCode: ConditionCode): number {
 	if (SEVERE_CONDITIONS.has(conditionCode)) {
-		return Math.min(1, baseUrgency + 0.3)
+		return Math.min(1, basePriority + 0.3)
 	}
 	if (MODERATE_CONDITIONS.has(conditionCode)) {
-		return Math.min(1, baseUrgency + 0.15)
+		return Math.min(1, basePriority + 0.15)
 	}
-	return baseUrgency
+	return basePriority
 }
 
-function adjustUrgencyForAlertSeverity(severity: Severity): number {
+function adjustPriorityForAlertSeverity(severity: Severity): number {
 	switch (severity) {
 		case "extreme":
 			return 1
@@ -218,29 +218,7 @@ function adjustUrgencyForAlertSeverity(severity: Severity): number {
 		case "moderate":
 			return 0.75
 		case "minor":
-			return BASE_URGENCY.alert
+			return BASE_PRIORITY.alert
-	}
-}
-
-function timeRelevanceForCondition(conditionCode: ConditionCode): TimeRelevance {
-	if (SEVERE_CONDITIONS.has(conditionCode)) {
-		return TimeRelevance.Imminent
-	}
-	if (MODERATE_CONDITIONS.has(conditionCode)) {
-		return TimeRelevance.Upcoming
-	}
-	return TimeRelevance.Ambient
-}
-
-function timeRelevanceForAlertSeverity(severity: Severity): TimeRelevance {
-	switch (severity) {
-		case "extreme":
-		case "severe":
-			return TimeRelevance.Imminent
-		case "moderate":
-			return TimeRelevance.Upcoming
-		case "minor":
-			return TimeRelevance.Ambient
 	}
 }
 
@@ -284,14 +262,12 @@ function createCurrentWeatherFeedItem(
 	timestamp: Date,
 	units: Units,
 ): WeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForCondition(BASE_PRIORITY.current, current.conditionCode)
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.current, current.conditionCode),
-		timeRelevance: timeRelevanceForCondition(current.conditionCode),
-	}
 
 	return {
 		id: `weather-current-${timestamp.getTime()}`,
 		type: WeatherFeedItemType.current,
+		priority,
 		timestamp,
 		data: {
 			conditionCode: current.conditionCode,
@@ -308,7 +284,6 @@ function createCurrentWeatherFeedItem(
 			windGust: convertSpeed(current.windGust, units),
 			windSpeed: convertSpeed(current.windSpeed, units),
 		},
-		signals,
 	}
 }
 
@@ -318,14 +293,12 @@ function createHourlyWeatherFeedItem(
 	timestamp: Date,
 	units: Units,
 ): WeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForCondition(BASE_PRIORITY.hourly, hourly.conditionCode)
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.hourly, hourly.conditionCode),
-		timeRelevance: timeRelevanceForCondition(hourly.conditionCode),
-	}
 
 	return {
 		id: `weather-hourly-${timestamp.getTime()}-${index}`,
 		type: WeatherFeedItemType.hourly,
+		priority,
 		timestamp,
 		data: {
 			forecastTime: new Date(hourly.forecastStart),
@@ -342,7 +315,6 @@ function createHourlyWeatherFeedItem(
 			windGust: convertSpeed(hourly.windGust, units),
 			windSpeed: convertSpeed(hourly.windSpeed, units),
 		},
-		signals,
 	}
 }
 
@@ -352,14 +324,12 @@ function createDailyWeatherFeedItem(
 	timestamp: Date,
 	units: Units,
 ): WeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForCondition(BASE_PRIORITY.daily, daily.conditionCode)
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.daily, daily.conditionCode),
-		timeRelevance: timeRelevanceForCondition(daily.conditionCode),
-	}
 
 	return {
 		id: `weather-daily-${timestamp.getTime()}-${index}`,
 		type: WeatherFeedItemType.daily,
+		priority,
 		timestamp,
 		data: {
 			forecastDate: new Date(daily.forecastStart),
@@ -374,19 +344,16 @@ function createDailyWeatherFeedItem(
 			temperatureMax: convertTemperature(daily.temperatureMax, units),
 			temperatureMin: convertTemperature(daily.temperatureMin, units),
 		},
-		signals,
 	}
 }
 
 function createWeatherAlertFeedItem(alert: WeatherAlert, timestamp: Date): WeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const priority = adjustPriorityForAlertSeverity(alert.severity)
-		urgency: adjustUrgencyForAlertSeverity(alert.severity),
-		timeRelevance: timeRelevanceForAlertSeverity(alert.severity),
-	}
 
 	return {
 		id: `weather-alert-${alert.id}`,
 		type: WeatherFeedItemType.alert,
+		priority,
 		timestamp,
 		data: {
 			alertId: alert.id,
@@ -400,6 +367,5 @@ function createWeatherAlertFeedItem(alert: WeatherAlert, timestamp: Date): Weath
 			source: alert.source,
 			urgency: alert.urgency,
 		},
-		signals,
 	}
 }