diff --git a/.formatter.exs b/.formatter.exs
index 045e92f..da1021b 100644
--- a/.formatter.exs
+++ b/.formatter.exs
@@ -3,7 +3,8 @@
   subdirectories: ["priv/*/migrations"],
   inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}", "priv/*/seeds.exs"]
 ]
+
 # The HEEx formatter is deliberatly disabled 
 #   because it keeps expanding single-line <span> tags 
 #   into multi-line blocks, which injects literal whitespace 
-#   into pre-wrap elements and causes a blank-line bug.
\ No newline at end of file
+#   into pre-wrap elements and causes a blank-line bug.
diff --git a/.gitignore b/.gitignore
index ecc5b87..c002366 100644
--- a/.gitignore
+++ b/.gitignore
@@ -41,3 +41,8 @@ npm-debug.log
 
 .secrets.txt
 .claude/
+
+# my notes
+elixdo*.md
+db_deletes.md
+MCP_SERVER_PLAN.md
diff --git a/MCP_SERVER_PLAN.md b/MCP_SERVER_PLAN.md
index eb172e3..96bf431 100644
--- a/MCP_SERVER_PLAN.md
+++ b/MCP_SERVER_PLAN.md
@@ -6,156 +6,268 @@ Add an embedded MCP (Model Context Protocol) controller that allows an AI like C
 
 ---
 
-## Step 1 — Add the MCP route
+## What was actually built (post-implementation notes)
 
-In `lib/elixdo_web/router.ex`, add one line inside the existing `api_auth` scope:
+This document was rewritten after the implementation was complete. The original plan had several gaps that only became apparent during integration testing with Claude Code. The sections below reflect what it actually takes to get a working MCP server.
+
+---
+
+## Step 1 — Add the MCP route in a dedicated scope
+
+The MCP endpoint must NOT share the `:api_auth` pipeline with the other API routes. The reason: the `:api_auth` pipeline uses `plug :accepts, ["json"]`, which causes Phoenix to return **406 Not Acceptable** when Claude Code sends `Accept: text/event-stream` — which it does for every request, as required by the MCP Streamable HTTP transport spec.
+
+The fix is a separate pipeline with no `:accepts` plug, since the MCP controller handles its own content negotiation:
 
 ```elixir
+# MCP handles its own content negotiation (JSON and SSE), so no :accepts plug here
+pipeline :mcp_auth do
+  plug ElixdoWeb.ApiAuthPlug
+end
+
 scope "/api/v1", ElixdoWeb.Api do
   pipe_through :api_auth
-
   # ... existing routes ...
-  post "/mcp", McpController, :handle   # ← add this
+end
+
+scope "/api/v1", ElixdoWeb.Api do
+  pipe_through :mcp_auth
+  post "/mcp", McpController, :handle
 end
 ```
 
-The MCP endpoint reuses the same `ApiAuthPlug` and `AGENT_TOKEN` already in place. No new auth work needed.
+**Do not** try to add `"event-stream"` to the accepts list — `text/event-stream` is not registered in Phoenix's MIME registry by default and will not work.
 
 ---
 
-## Step 2 — Create `mcp_controller.ex`
+## Step 2 — Implement the Streamable HTTP transport
 
-Create `lib/elixdo_web/controllers/api/mcp_controller.ex`. It handles JSON-RPC 2.0 dispatch:
+Claude Code uses the **MCP Streamable HTTP transport**, which requires the server to check the `Accept` request header and respond in either plain JSON or SSE format accordingly.
 
-```elixir
-defmodule ElixdoWeb.Api.McpController do
-  use ElixdoWeb, :controller
-  alias Elixdo.{Lists, SearchIndex, Clock, DateHelper}
-
-  def handle(conn, %{"method" => "initialize", "id" => id}) do
-    json(conn, %{
-      jsonrpc: "2.0", id: id,
-      result: %{
-        protocolVersion: "2024-11-05",
-        serverInfo: %{name: "elixdo", version: "1.0"},
-        capabilities: %{tools: %{}}
-      }
-    })
-  end
+When the client sends `Accept: text/event-stream`, the response must be:
+```
+Content-Type: text/event-stream
+Cache-Control: no-cache
 
-  def handle(conn, %{"method" => "tools/list", "id" => id}) do
-    json(conn, %{jsonrpc: "2.0", id: id, result: %{tools: tool_definitions()}})
-  end
+event: message
+data: {"jsonrpc":"2.0","id":1,"result":{...}}
 
-  def handle(conn, %{"method" => "tools/call", "id" => id,
-                     "params" => %{"name" => name, "arguments" => args}}) do
-    result = dispatch(name, args)
-    json(conn, %{jsonrpc: "2.0", id: id, result: %{content: [%{type: "text", text: Jason.encode!(result)}]}})
-  end
+```
+
+Note the blank line at the end (`\n\n`) — that terminates the SSE event.
 
-  def handle(conn, %{"id" => id}) do
-    json(conn, %{jsonrpc: "2.0", id: id,
-      error: %{code: -32601, message: "Method not found"}})
+Use a private `respond/2` helper in the controller so all clauses stay clean:
+
+```elixir
+defp respond(conn, payload) do
+  accept = get_req_header(conn, "accept") |> List.first("")
+
+  if String.contains?(accept, "text/event-stream") do
+    data = Jason.encode!(payload)
+    conn
+    |> put_resp_content_type("text/event-stream")
+    |> put_resp_header("cache-control", "no-cache")
+    |> send_resp(200, "event: message\ndata: #{data}\n\n")
+  else
+    json(conn, payload)
   end
 end
 ```
 
+Call `respond/2` instead of `json/2` in every handler clause.
+
 ---
 
-## Step 3 — Implement the tool dispatcher
+## Step 3 — Handle JSON-RPC notifications (no `id` field)
 
-Still in `mcp_controller.ex`, add a private `dispatch/2` that maps tool names to `Lists` calls.
+After `initialize`, Claude Code sends a `notifications/initialized` notification. JSON-RPC notifications have no `id` field. If your catch-all handler pattern-matches on `%{"id" => id}`, it will not match and Phoenix will return **400 Bad Request**, breaking the handshake.
 
-### Tools to expose
+Add a final catch-all that returns **204 No Content** for all notifications:
 
-| Tool name | Maps to | Purpose |
-|---|---|---|
-| `get_today` | `Clock.today()` | AI needs to know the current date for relative operations |
-| `list_items` | `Lists.get_items_for_date(date)` | Get items for a specific date |
-| `list_items_range` | `Lists.get_items_for_range(from, to, statuses)` | Get items across a date range, optionally filtered by status |
-| `add_item` | `Lists.create_items(date, [%{body: body}])` | Add a new item |
-| `update_item` | `Repo.get(ListItem, id)` + `Lists.update_item(item, attrs)` | Edit body, status, color, bold, italic, highlighted, prefix |
-| `arrow_item` | `Repo.get` + `Lists.arrow_item(item, to_date)` | Move item forward to another date |
-| `search_items` | `SearchIndex.search(query)` | Full-text search across all items |
+```elixir
+# JSON-RPC notifications have no "id" — acknowledge with 204, no body.
+def handle(conn, _params) do
+  send_resp(conn, 204, "")
+end
+```
 
-Note: `update_item` and `arrow_item` need a `Repo.get` first — identical to what `ItemController` already does. Extract that into a shared private function or a helper in the `Lists` context.
+This must be the last `handle/2` clause. The MCP handshake will fail silently without it.
 
 ---
 
-## Step 4 — Define tool schemas
+## Step 4 — Implement the JSON-RPC 2.0 dispatch
 
-The `tool_definitions()` function returns JSON Schema for each tool so the AI knows what arguments to pass. Example for `list_items`:
+The controller handles four cases: `initialize`, `tools/list`, `tools/call`, and the unknown-method fallback (before the notification catch-all):
 
 ```elixir
-%{
-  name: "list_items",
-  description: "Get all items for a specific date",
-  inputSchema: %{
-    type: "object",
-    properties: %{
-      date: %{type: "string", description: "ISO 8601 date, e.g. 2026-05-04"}
-    },
-    required: ["date"]
-  }
-}
+def handle(conn, %{"method" => "initialize", "id" => id}) do
+  respond(conn, %{
+    jsonrpc: "2.0", id: id,
+    result: %{
+      protocolVersion: "2024-11-05",
+      serverInfo: %{name: "elixdo", version: "1.0"},
+      capabilities: %{tools: %{}}
+    }
+  })
+end
+
+def handle(conn, %{"method" => "tools/list", "id" => id}) do
+  respond(conn, %{jsonrpc: "2.0", id: id, result: %{tools: tool_definitions()}})
+end
+
+def handle(conn, %{"method" => "tools/call", "id" => id,
+                   "params" => %{"name" => name, "arguments" => args}}) do
+  result = dispatch(name, args)
+  respond(conn, %{
+    jsonrpc: "2.0", id: id,
+    result: %{content: [%{type: "text", text: Jason.encode!(result)}]}
+  })
+end
+
+def handle(conn, %{"id" => id}) do
+  respond(conn, %{jsonrpc: "2.0", id: id,
+    error: %{code: -32601, message: "Method not found"}})
+end
+
+# Must be last — notifications have no "id"
+def handle(conn, _params) do
+  send_resp(conn, 204, "")
+end
 ```
 
-Write one schema for each of the seven tools. The descriptions matter — they are how the AI decides which tool to call.
+---
+
+## Step 5 — Implement the tool dispatcher
+
+The `dispatch/2` function maps tool names to `Lists` context calls. Key notes:
+
+- **Emoji shortcode conversion**: `add_item` and `update_item` must call `Emoji.convert/1` on the body before storing — exactly as the LiveView handlers do. If you skip this, shortcodes like `:fire:` are stored as literal text.
+- **`update_item` body is optional**: use a private helper to only convert body when the key is present:
+  ```elixir
+  defp convert_body(%{"body" => body} = attrs), do: Map.put(attrs, "body", Emoji.convert(body))
+  defp convert_body(attrs), do: attrs
+  ```
+- **`search_items`**: `SearchIndex.search/1` returns `{id, date, body}` tuples, not `ListItem` structs. Serialize manually — do NOT pass to `ItemJSON.item/1`.
+- **`arrow_item`**: use `DateHelper.resolve/1` (not `Date.from_iso8601/1`) so relative strings like `"tomorrow"` work.
+
+### Tools exposed
+
+| Tool | Maps to | Notes |
+|---|---|---|
+| `get_today` | `Clock.today()` | Returns `%{today: "2026-05-04"}` |
+| `list_items` | `Lists.get_items_for_date(date)` | |
+| `list_items_range` | `Lists.get_items_for_range(from, to, statuses)` | `statuses` is optional; map strings to atoms |
+| `add_item` | `Lists.create_items(date, [%{body: body}])` | Apply `Emoji.convert/1` first |
+| `update_item` | `Repo.get` + `Lists.update_item(item, attrs)` | Apply `Emoji.convert/1` to body if present |
+| `arrow_item` | `Repo.get` + `Lists.arrow_item(item, to_date)` | Use `DateHelper.resolve/1` for target date |
+| `search_items` | `SearchIndex.search(query)` | Returns tuples — serialize manually |
 
 ---
 
-## Step 5 — Set the `AGENT_TOKEN` environment variable
+## Step 6 — Register the server with Claude Code CLI
 
-The token already gates the `/api/v1` routes. On Fly.io:
+**The `mcpServers` key in `~/.claude/settings.json` is ignored by Claude Code.** That file controls permissions and hooks only. MCP servers must be registered using the CLI command, which writes to `~/.claude.json`:
 
 ```sh
-fly secrets set AGENT_TOKEN=<a long random string>
+claude mcp add --transport http --scope user elixdo \
+  https://yourapp.fly.dev/api/v1/mcp \
+  --header "Authorization: Bearer <AGENT_TOKEN>"
+```
+
+Verify with:
+```sh
+claude mcp list
 ```
 
-Locally, add to `.env` or `config/dev.secret.exs`. The MCP client sends this as `Authorization: Bearer <token>`.
+You should see `elixdo: ... (HTTP) - ✓ Connected`. If you see `✗ Failed to connect`, run through the troubleshooting section below.
+
+After registering, **start a new Claude Code session**. MCP servers are connected at session startup. Existing sessions will not see the new tools.
 
 ---
 
-## Step 6 — Configure Claude to use the MCP server
+## Step 7 — Set the `AGENT_TOKEN` on Fly.io
 
-### Claude Code CLI
+```sh
+fly secrets set AGENT_TOKEN=<a long random string>
+```
 
-Add to `~/.claude/settings.json` (or the project-level `.claude/settings.json`):
+The token gates the `/api/v1/mcp` route via the existing `ApiAuthPlug`. Verify it is set:
 
-```json
-{
-  "mcpServers": {
-    "elixdo": {
-      "type": "http",
-      "url": "https://yourapp.fly.dev/api/v1/mcp",
-      "headers": {
-        "Authorization": "Bearer <AGENT_TOKEN>"
-      }
-    }
-  }
-}
+```sh
+fly secrets list --app <appname>
 ```
 
-### Claude.ai web app
+---
 
-Go to Settings → Integrations → Add MCP server. Set the URL to `https://yourapp.fly.dev/api/v1/mcp` and add the bearer token in the headers field.
+## Files changed
 
-After connecting, Claude will call `tools/list` automatically and discover the available tools. You can then say things like "add 'buy milk' to today's list" or "show me everything I marked complete last week."
+| File | Action |
+|---|---|
+| `lib/elixdo_web/router.ex` | Add `:mcp_auth` pipeline and separate MCP scope |
+| `lib/elixdo_web/controllers/api/mcp_controller.ex` | Create (~160 lines) |
 
 ---
 
-## What's not needed
+## Troubleshooting: `✗ Failed to connect`
 
-- No new authentication — `AGENT_TOKEN` already exists
-- No new context functions — `Lists` already exposes everything needed
-- No streaming/SSE — all operations are synchronous, plain JSON responses are sufficient
-- No second process or deployment — this lives in the existing Phoenix app
+Work through these in order:
 
----
+**1. Test the initialize handshake directly:**
+```sh
+curl -X POST https://yourapp.fly.dev/api/v1/mcp \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer <token>" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}'
+```
+Should return 200 with `protocolVersion`. If 401, the token is wrong. If 404, the route isn't deployed.
 
-## Files to change
+**2. Test SSE response:**
+```sh
+curl -X POST https://yourapp.fly.dev/api/v1/mcp \
+  -H "Content-Type: application/json" \
+  -H "Accept: text/event-stream" \
+  -H "Authorization: Bearer <token>" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
+```
+Should return `event: message\ndata: {...}`. If 406, Phoenix is rejecting `text/event-stream` — the MCP pipeline is using `plug :accepts`.
 
-| File | Action |
-|---|---|
-| `lib/elixdo_web/router.ex` | Add 1 line |
-| `lib/elixdo_web/controllers/api/mcp_controller.ex` | Create (~120 lines) |
+**3. Test notification handling:**
+```sh
+curl -X POST https://yourapp.fly.dev/api/v1/mcp \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer <token>" \
+  -d '{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}'
+```
+Should return 204. If 400, the notification catch-all handler is missing.
+
+**4. Check tools actually load in a new session:**
+```sh
+claude mcp list
+```
+If `✓ Connected` but tools still don't appear as `mcp__elixdo__*` in a session, restart the session — tools are loaded at startup only.
+
+---
+
+## Test plan
+
+Write these tests before implementing. All should be red until the implementation is complete.
+
+**Core protocol:**
+1. `initialize returns correct protocol version and capabilities`
+2. `tools/list returns all seven tool definitions with required fields`
+3. `notifications return 204 with empty body` ← easy to miss, critical for handshake
+4. `unknown method returns -32601 error`
+5. `missing auth returns 401`
+6. `responds with SSE format when Accept: text/event-stream` ← tests the transport layer
+
+**Tool behaviour:**
+7. `get_today returns today's date`
+8. `list_items returns items for a date`
+9. `list_items_range returns items across a date range`
+10. `list_items_range with status filter returns only matching items`
+11. `add_item creates item and it appears in list_items`
+12. `add_item converts shortcodes in body`
+13. `update_item changes item body`
+14. `update_item converts shortcodes in body`
+15. `update_item without body field is unaffected by shortcode conversion`
+16. `arrow_item marks original arrowed_out and creates copy on target date`
+17. `search_items returns matching results`
diff --git a/assets/css/app.css b/assets/css/app.css
index 434d73e..a5c00bc 100644
--- a/assets/css/app.css
+++ b/assets/css/app.css
@@ -225,47 +225,12 @@ body {
   line-height: 1;
 }
 .toolbar-btn:hover { background: var(--bg-4); color: white; }
+.priority-btn { color: var(--text); font-size: 22px; padding: 0 4px; min-width: unset; }
 
-/* Select-all button — ring matches item-select-btn */
-.select-btn {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 40px;
-  height: 40px;
-  background: var(--bg-3);
-  border: 1px solid var(--border-light);
-  border-radius: var(--radius-btn);
-  cursor: pointer;
-  transition: all 0.12s;
-  position: relative;
-}
-.select-btn::before {
-  content: "";
-  width: 22px;
-  height: 22px;
-  border-radius: 50%;
-  border: 2px solid oklch(72% 0.015 280);
-  transition: all 0.12s;
-  flex-shrink: 0;
-}
-.select-btn:hover::before { border-color: var(--accent); }
-.select-btn.selected::before {
-  background: var(--accent);
-  border-color: var(--accent);
-}
-.select-btn.selected::after {
-  content: "";
-  position: absolute;
-  width: 7px;
-  height: 7px;
-  border-radius: 50%;
-  background: white;
-  pointer-events: none;
-}
 
-/* Search button */
-.search-btn {
+/* Search and sort buttons */
+.search-btn,
+.sort-btn {
   display: flex;
   align-items: center;
   justify-content: center;
@@ -278,7 +243,8 @@ body {
   cursor: pointer;
   transition: all 0.12s;
 }
-.search-btn:hover { border-color: var(--accent); color: white; }
+.search-btn:hover,
+.sort-btn:hover { border-color: var(--accent); color: white; }
 
 /* Color swatches row — same 40px height */
 .swatches-row {
@@ -309,43 +275,83 @@ body {
 .swatch-purple { background: var(--c-purple); }
 .swatch-orange { background: var(--c-orange); }
 
-/* Prefix input — matches toolbar height */
-.prefix-form { display: flex; align-items: center; }
-.prefix-input {
-  width: 44px;
-  height: 40px;
-  padding: 0 8px;
-  background: var(--bg-4);
-  border: 1px solid var(--border-light);
-  border-radius: var(--radius-btn);
-  color: var(--text);
-  font-family: inherit;
-  font-size: 12px;
-  text-align: center;
+/* Mobile priority trigger button — hidden on desktop, shown on coarse */
+.priority-mobile-btn { display: none; font-size: 22px; }
+
+/* Priority bottom sheet icons */
+.priority-sheet-btn {
+  background: none;
+  border: none;
+  font-size: 44px;
+  cursor: pointer;
+  padding: 4px 8px;
+  transition: transform 0.1s;
+}
+.priority-sheet-btn:hover,
+.priority-sheet-btn:active { transform: scale(1.2); }
+
+/* Mobile color trigger button — hidden on desktop, shown on coarse */
+.color-mobile-btn {
+  display: none;
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  border: 2px solid var(--border-color);
+  cursor: pointer;
+  flex-shrink: 0;
+}
+.color-mobile-btn:hover { transform: scale(1.15); border-color: var(--text); }
+
+/* Color bottom sheet */
+.bottom-sheet-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.45);
+  z-index: 200;
+  display: flex;
+  align-items: flex-end;
+}
+.bottom-sheet {
+  width: 100%;
+  background: var(--bg-2);
+  border-top: 1px solid var(--border-color);
+  border-radius: 16px 16px 0 0;
+  padding: 24px 16px 32px;
+  display: flex;
+  justify-content: center;
+  gap: 20px;
 }
-.prefix-input::placeholder { color: var(--text-dim); }
-.prefix-input:focus { outline: none; border-color: var(--accent); }
+.color-sheet-swatch {
+  width: 52px;
+  height: 52px;
+  border-radius: 50%;
+  border: 3px solid transparent;
+  cursor: pointer;
+  flex-shrink: 0;
+  transition: transform 0.1s;
+}
+.color-sheet-swatch:hover,
+.color-sheet-swatch:active { transform: scale(1.2); border-color: var(--text); }
 
 /* Today button */
 .today-btn {
   display: flex;
   align-items: center;
-  gap: 5px;
+  justify-content: center;
+  width: 26px;
   height: 40px;
-  padding: 0 14px;
-  background: oklch(63% 0.27 293 / 0.14);
-  border: 1px solid var(--accent-dim);
+  padding: 0;
+  background: var(--bg-2);
+  border: 1px solid var(--border-color);
   border-radius: var(--radius-btn);
-  color: var(--accent);
+  color: oklch(82% 0.012 280);
   font-family: inherit;
   font-size: 24px;
-  font-weight: 600;
   cursor: pointer;
-  letter-spacing: 0.02em;
   transition: all 0.12s;
-  white-space: nowrap;
+  flex-shrink: 0;
 }
-.today-btn:hover { background: oklch(63% 0.27 293 / 0.24); }
+.today-btn:hover { border-color: var(--accent); color: white; }
 
 /* Hide old separator */
 .toolbar-sep { display: none; }
@@ -515,6 +521,14 @@ body {
 .drag-handle:active { cursor: grabbing; }
 .drag-ghost { opacity: 0.35; }
 
+/* Priority character: always visible, full color, slightly larger than ⠿ */
+.drag-handle.drag-handle--priority {
+  opacity: 1;
+  color: var(--text);
+  font-size: 20px;
+  transition: none;
+}
+
 /* ─── Per-item select button ────────────────────────────────────────── */
 
 .item-select-btn {
@@ -545,23 +559,6 @@ body {
   background: white;
 }
 
-/* ─── Prefix badge ──────────────────────────────────────────────────── */
-
-.prefix-badge {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 28px;
-  height: 28px;
-  padding: 0 5px;
-  background: var(--bg-4);
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  font-size: 15px;
-  line-height: 1;
-  flex-shrink: 0;
-}
-
 /* ─── Item body ─────────────────────────────────────────────────────── */
 
 .item-body {
@@ -573,14 +570,6 @@ body {
   line-height: 1.2;
   cursor: pointer;
 }
-.item-body.bold   { font-weight: 700; }
-.item-body.italic { font-style: italic; }
-.item-body.highlighted .item-text {
-  background: oklch(85% 0.16 90 / 0.28);
-  border-radius: 3px;
-  padding: 0 2px;
-}
-
 .item-body.color-red    { color: oklch(72% 0.20 17); }
 .item-body.color-blue   { color: oklch(72% 0.18 240); }
 .item-body.color-green  { color: oklch(72% 0.16 145); }
@@ -655,12 +644,12 @@ body {
 .add-item-input {
   flex: 1;
   padding: 10px 14px;
-  background: var(--bg-2);
+  background: #000;
   border: 1px solid var(--border-color);
   border-radius: var(--radius-card);
   color: var(--text);
   font-family: inherit;
-  font-size: 15px;
+  font-size: 20px;
   resize: none;
   min-height: 44px;
   transition: border-color 0.12s, box-shadow 0.12s;
@@ -680,7 +669,7 @@ body {
   border: none;
   border-radius: var(--radius-card);
   font-family: inherit;
-  font-size: 24px;
+  font-size: 20px;
   font-weight: 600;
   cursor: pointer;
   letter-spacing: 0.02em;
@@ -690,6 +679,30 @@ body {
 .add-btn:hover { background: var(--accent-dim); }
 .add-btn:active { transform: scale(0.97); }
 
+.mic-btn {
+  padding: 0 12px;
+  align-self: stretch;
+  background: var(--bg-2);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  color: var(--text-dim);
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+  transition: background 0.12s, color 0.12s;
+}
+.mic-btn:hover { background: var(--bg-3); color: var(--text); }
+.mic-btn.mic-recording {
+  color: #e53;
+  animation: mic-pulse 1s ease-in-out infinite;
+}
+@keyframes mic-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+
 /* ═══════════════════════════════════════════════════════════════════════
    MODALS
    ═══════════════════════════════════════════════════════════════════════ */
@@ -817,11 +830,18 @@ body {
   .item { padding: 16px 14px 16px 16px; gap: 12px; }
   .item-body { font-size: 22px; line-height: 1.25; }
   .drag-handle { opacity: 0.4; font-size: 20px; padding: 0 0.6rem; min-width: 2rem; text-align: center; }
+  .drag-handle.drag-handle--priority { opacity: 1; font-size: 26px; }
   .item-select-btn { width: 32px; height: 32px; }
   .item-select-btn.selected::after { width: 8px; height: 8px; }
   .toolbar-btn { min-width: 40px; height: 38px; }
-  .add-item-input { font-size: 1.1rem; padding: 0.75rem; }
+  .priority-btn { font-size: 22px; padding: 0 4px; min-width: unset; }
+  .today-btn { font-size: 48px; width: 48px; }
+  .add-item-input { font-size: 20px; padding: 0.75rem; }
   .date-header { padding: 0.75rem; }
   .nav-arrow { font-size: 2rem; padding: 0.5rem 1.2rem; }
   .search-modal { min-width: unset; width: 90vw; }
+  .swatches-row { display: none; }
+  .color-mobile-btn { display: block; }
+  .priority-desktop-group { display: none; }
+  .priority-mobile-btn { display: flex; align-items: center; justify-content: center; }
 }
diff --git a/assets/js/app.js b/assets/js/app.js
index a3743f4..8c1c304 100644
--- a/assets/js/app.js
+++ b/assets/js/app.js
@@ -28,6 +28,7 @@ import Swipe from "./swipe"
 import AddItem from "./add_item"
 import EditItem from "./edit_item"
 import DragSort from "./drag_sort"
+import VoiceInput from "./voice_input"
 
 const SearchFocus = {
   mounted() { this.el.focus() }
@@ -39,6 +40,7 @@ Hooks.AddItem = AddItem
 Hooks.EditItem = EditItem
 Hooks.DragSort = DragSort
 Hooks.SearchFocus = SearchFocus
+Hooks.VoiceInput = VoiceInput
 
 const csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content")
 const liveSocket = new LiveSocket("/live", Socket, {
diff --git a/assets/js/voice_input.js b/assets/js/voice_input.js
new file mode 100644
index 0000000..1bbe6eb
--- /dev/null
+++ b/assets/js/voice_input.js
@@ -0,0 +1,42 @@
+const VoiceInput = {
+  mounted() {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (!SpeechRecognition) return; // leave hidden on unsupported browsers
+
+    this.el.style.display = "";
+
+    const recognition = new SpeechRecognition();
+    recognition.lang = "en-US";
+    recognition.interimResults = false;
+    recognition.maxAlternatives = 1;
+
+    let recording = false;
+
+    recognition.onresult = (e) => {
+      const transcript = e.results[0][0].transcript;
+      this.pushEvent("voice_input", {text: transcript});
+    };
+
+    recognition.onend = () => {
+      recording = false;
+      this.el.classList.remove("mic-recording");
+    };
+
+    recognition.onerror = () => {
+      recording = false;
+      this.el.classList.remove("mic-recording");
+    };
+
+    this.el.addEventListener("click", () => {
+      if (recording) {
+        recognition.stop();
+      } else {
+        recognition.start();
+        recording = true;
+        this.el.classList.add("mic-recording");
+      }
+    });
+  }
+};
+
+export default VoiceInput;
diff --git a/lib/elixdo/emoji.ex b/lib/elixdo/emoji.ex
index 1cec7f2..03f69ab 100644
--- a/lib/elixdo/emoji.ex
+++ b/lib/elixdo/emoji.ex
@@ -3,7 +3,6 @@
 #   On Windows: Win + . opens the emoji picker
 #   On Mac: Cmd + Ctrl + Space
 
-
 defmodule Elixdo.Emoji do
   @moduledoc "Converts :shortcode: patterns to emoji characters."
 
@@ -45,7 +44,7 @@ defmodule Elixdo.Emoji do
     "warning" => "⚠️",
     "tada" => "🎉",
     "rocket" => "🚀",
-    "bulb" => "💡",
+    "idea" => "💡",
     "memo" => "📝",
     "calendar" => "📅",
     "clock" => "🕐",
@@ -57,7 +56,6 @@ defmodule Elixdo.Emoji do
     "dog" => "🐶",
     "cat" => "🐱",
     "pizza" => "🍕",
-    "coffee" => "☕",
     "lock" => "🔒",
     "key" => "🔑",
     "wrench" => "🔧",
diff --git a/lib/elixdo/list_item.ex b/lib/elixdo/list_item.ex
index 0e7256b..fcad867 100644
--- a/lib/elixdo/list_item.ex
+++ b/lib/elixdo/list_item.ex
@@ -1,7 +1,11 @@
 defmodule Elixdo.ListItem do
+  @moduledoc "Ecto schema for a single task item. Defines fields, enums, and validation rules."
+
   use Ecto.Schema
   import Ecto.Changeset
 
+  @valid_priorities ["❶", "❷", "❸", "⭐", "🔥"]
+
   schema "list_items" do
     field :date, :date
     field :position, :integer
@@ -12,15 +16,16 @@ defmodule Elixdo.ListItem do
       default: :active
 
     field :color, Ecto.Enum, values: [:red, :blue, :green, :purple, :orange]
-    field :bold, :boolean, default: false
-    field :italic, :boolean, default: false
-    field :highlighted, :boolean, default: false
-    field :prefix, :string
+    field :priority, :string
     field :arrowed_to_date, :date
 
     timestamps(type: :utc_datetime)
   end
 
+  def colors, do: Ecto.Enum.values(__MODULE__, :color)
+  def color_strings, do: Enum.map(colors(), &Atom.to_string/1)
+  def priorities, do: @valid_priorities
+
   def changeset(item, attrs) do
     item
     |> cast(attrs, [
@@ -29,17 +34,23 @@ defmodule Elixdo.ListItem do
       :body,
       :status,
       :color,
-      :bold,
-      :italic,
-      :highlighted,
-      :prefix,
+      :priority,
       :arrowed_to_date
     ])
     |> validate_required([:date, :position, :body])
     |> validate_length(:body, min: 1)
+    |> validate_priority()
     |> validate_arrowed_to_date_consistency()
   end
 
+  defp validate_priority(changeset) do
+    case get_change(changeset, :priority) do
+      nil -> changeset
+      p when p in @valid_priorities -> changeset
+      _ -> add_error(changeset, :priority, "must be one of #{Enum.join(@valid_priorities, ", ")}")
+    end
+  end
+
   # arrowed_to_date must be set iff status is arrowed_out
   defp validate_arrowed_to_date_consistency(changeset) do
     status = get_field(changeset, :status)
diff --git a/lib/elixdo/lists.ex b/lib/elixdo/lists.ex
index b932684..c719bdc 100644
--- a/lib/elixdo/lists.ex
+++ b/lib/elixdo/lists.ex
@@ -2,11 +2,27 @@ defmodule Elixdo.Lists do
   @moduledoc "Public API for list operations. Routes through per-date GenServer."
 
   alias Elixdo.Lists.{Server, DB}
+  alias Elixdo.Emoji
 
   def get_items_for_date(date), do: Server.get_items(date)
-  def get_items_for_range(from_date, to_date, statuses \\ nil), do: DB.get_items_for_range(from_date, to_date, statuses)
-  def create_items(date, attrs), do: Server.create_items(date, attrs)
-  def update_item(item, attrs), do: Server.update_item(item.date, item, attrs)
+
+  def get_items_for_range(from_date, to_date, statuses \\ nil),
+    do: DB.get_items_for_range(from_date, to_date, statuses)
+
+  def create_items(date, attrs) do
+    attrs = Enum.map(attrs, &convert_body/1)
+    Server.create_items(date, attrs)
+  end
+
+  def update_item(item, attrs) do
+    attrs = convert_body(attrs)
+    Server.update_item(item.date, item, attrs)
+  end
+
   def arrow_item(item, to_date), do: Server.arrow_item(item.date, item, to_date)
   def reorder_items(date, ids), do: Server.reorder_items(date, ids)
+
+  defp convert_body(%{body: body} = attrs), do: %{attrs | body: Emoji.convert(body)}
+  defp convert_body(%{"body" => body} = attrs), do: %{attrs | "body" => Emoji.convert(body)}
+  defp convert_body(attrs), do: attrs
 end
diff --git a/lib/elixdo/lists/db.ex b/lib/elixdo/lists/db.ex
index 6fdd104..9140666 100644
--- a/lib/elixdo/lists/db.ex
+++ b/lib/elixdo/lists/db.ex
@@ -93,11 +93,7 @@ defmodule Elixdo.Lists.DB do
       create_items(to_date, [
         %{
           body: item.body,
-          color: item.color,
-          bold: item.bold,
-          italic: item.italic,
-          highlighted: item.highlighted,
-          prefix: item.prefix
+          color: item.color
         }
       ])
     end)
diff --git a/lib/elixdo/search_index.ex b/lib/elixdo/search_index.ex
index af67c8f..980e779 100644
--- a/lib/elixdo/search_index.ex
+++ b/lib/elixdo/search_index.ex
@@ -49,7 +49,6 @@ defmodule Elixdo.SearchIndex do
     results =
       :ets.tab2list(:search_index)
       |> Enum.filter(fn {_id, _date, body} -> String.contains?(body, query) end)
-      |> Enum.map(fn {id, date, body} -> {id, date, body} end)
 
     {:reply, results, state}
   end
diff --git a/lib/elixdo_web/controllers/api/helpers.ex b/lib/elixdo_web/controllers/api/helpers.ex
new file mode 100644
index 0000000..903f203
--- /dev/null
+++ b/lib/elixdo_web/controllers/api/helpers.ex
@@ -0,0 +1,12 @@
+defmodule ElixdoWeb.Api.Helpers do
+  @moduledoc false
+  alias Elixdo.{Repo, ListItem}
+
+  @doc "Fetch a ListItem by id, returning {:ok, item} or {:error, :not_found}."
+  def fetch_item(id) do
+    case Repo.get(ListItem, id) do
+      nil -> {:error, :not_found}
+      item -> {:ok, item}
+    end
+  end
+end
diff --git a/lib/elixdo_web/controllers/api/item_controller.ex b/lib/elixdo_web/controllers/api/item_controller.ex
index 1daded7..c56c87c 100644
--- a/lib/elixdo_web/controllers/api/item_controller.ex
+++ b/lib/elixdo_web/controllers/api/item_controller.ex
@@ -1,8 +1,9 @@
 defmodule ElixdoWeb.Api.ItemController do
+  @moduledoc false
   use ElixdoWeb, :controller
 
-  alias Elixdo.{Lists, DateHelper, Repo, ListItem}
-  alias ElixdoWeb.Api.ItemJSON
+  alias Elixdo.{Lists, DateHelper}
+  alias ElixdoWeb.Api.{ItemJSON, Helpers}
 
   # PATCH /api/v1/items/:id
   def update(conn, %{"id" => id} = params) do
@@ -19,7 +20,9 @@ defmodule ElixdoWeb.Api.ItemController do
       {:error, :forbidden_transition} ->
         conn
         |> put_status(422)
-        |> json(%{error: %{code: "forbidden_transition", message: "Status transition is not allowed"}})
+        |> json(%{
+          error: %{code: "forbidden_transition", message: "Status transition is not allowed"}
+        })
 
       {:error, changeset} ->
         conn
@@ -48,7 +51,9 @@ defmodule ElixdoWeb.Api.ItemController do
       {:error, :forbidden_transition} ->
         conn
         |> put_status(422)
-        |> json(%{error: %{code: "forbidden_transition", message: "Only active items can be arrowed"}})
+        |> json(%{
+          error: %{code: "forbidden_transition", message: "Only active items can be arrowed"}
+        })
 
       {:error, _} ->
         conn
@@ -63,10 +68,5 @@ defmodule ElixdoWeb.Api.ItemController do
     |> json(%{error: %{code: "validation_error", message: "target_date is required"}})
   end
 
-  defp fetch_item(id) do
-    case Repo.get(ListItem, id) do
-      nil -> {:error, :not_found}
-      item -> {:ok, item}
-    end
-  end
+  defp fetch_item(id), do: Helpers.fetch_item(id)
 end
diff --git a/lib/elixdo_web/controllers/api/item_json.ex b/lib/elixdo_web/controllers/api/item_json.ex
index e25df92..ebd38c8 100644
--- a/lib/elixdo_web/controllers/api/item_json.ex
+++ b/lib/elixdo_web/controllers/api/item_json.ex
@@ -1,4 +1,5 @@
 defmodule ElixdoWeb.Api.ItemJSON do
+  @moduledoc false
   alias Elixdo.ListItem
 
   @doc "Serialize a single ListItem to a JSON-safe map."
@@ -9,11 +10,8 @@ defmodule ElixdoWeb.Api.ItemJSON do
       body: item.body,
       status: to_string(item.status),
       position: item.position,
-      bold: item.bold,
-      italic: item.italic,
-      highlighted: item.highlighted,
       color: item.color && to_string(item.color),
-      prefix: item.prefix,
+      priority: item.priority,
       arrowed_to_date: item.arrowed_to_date && Date.to_iso8601(item.arrowed_to_date),
       inserted_at: format_datetime(item.inserted_at),
       updated_at: format_datetime(item.updated_at)
diff --git a/lib/elixdo_web/controllers/api/list_controller.ex b/lib/elixdo_web/controllers/api/list_controller.ex
index 0836c2e..1f0ac9c 100644
--- a/lib/elixdo_web/controllers/api/list_controller.ex
+++ b/lib/elixdo_web/controllers/api/list_controller.ex
@@ -1,4 +1,5 @@
 defmodule ElixdoWeb.Api.ListController do
+  @moduledoc false
   use ElixdoWeb, :controller
 
   alias Elixdo.{Lists, DateHelper}
@@ -69,7 +70,9 @@ defmodule ElixdoWeb.Api.ListController do
       {:error, :partial_reorder} ->
         conn
         |> put_status(422)
-        |> json(%{error: %{code: "partial_reorder", message: "IDs do not match items on this date"}})
+        |> json(%{
+          error: %{code: "partial_reorder", message: "IDs do not match items on this date"}
+        })
 
       {:error, _} ->
         conn
diff --git a/lib/elixdo_web/controllers/api/mcp_controller.ex b/lib/elixdo_web/controllers/api/mcp_controller.ex
new file mode 100644
index 0000000..0a6512b
--- /dev/null
+++ b/lib/elixdo_web/controllers/api/mcp_controller.ex
@@ -0,0 +1,230 @@
+defmodule ElixdoWeb.Api.McpController do
+  @moduledoc false
+  use ElixdoWeb, :controller
+
+  alias Elixdo.{Lists, SearchIndex, Clock, DateHelper, ListItem}
+  alias ElixdoWeb.Api.{ItemJSON, Helpers}
+
+  # ---------------------------------------------------------------------------
+  # JSON-RPC 2.0 dispatch
+  # ---------------------------------------------------------------------------
+
+  def handle(conn, %{"method" => "initialize", "id" => id}) do
+    respond(conn, %{
+      jsonrpc: "2.0",
+      id: id,
+      result: %{
+        protocolVersion: "2024-11-05",
+        serverInfo: %{name: "elixdo", version: "1.0"},
+        capabilities: %{tools: %{}}
+      }
+    })
+  end
+
+  def handle(conn, %{"method" => "tools/list", "id" => id}) do
+    respond(conn, %{jsonrpc: "2.0", id: id, result: %{tools: tool_definitions()}})
+  end
+
+  def handle(conn, %{
+        "method" => "tools/call",
+        "id" => id,
+        "params" => %{"name" => name, "arguments" => args}
+      }) do
+    result = dispatch(name, args)
+    respond(conn, %{
+      jsonrpc: "2.0",
+      id: id,
+      result: %{content: [%{type: "text", text: Jason.encode!(result)}]}
+    })
+  end
+
+  def handle(conn, %{"id" => id}) do
+    respond(conn, %{
+      jsonrpc: "2.0",
+      id: id,
+      error: %{code: -32601, message: "Method not found"}
+    })
+  end
+
+  # JSON-RPC notifications have no "id" — acknowledge with 204, no body.
+  def handle(conn, _params) do
+    send_resp(conn, 204, "")
+  end
+
+  # ---------------------------------------------------------------------------
+  # Streamable HTTP transport: respond as SSE or plain JSON based on Accept
+  # ---------------------------------------------------------------------------
+
+  defp respond(conn, payload) do
+    accept = get_req_header(conn, "accept") |> List.first("")
+
+    if String.contains?(accept, "text/event-stream") do
+      data = Jason.encode!(payload)
+
+      conn
+      |> put_resp_content_type("text/event-stream")
+      |> put_resp_header("cache-control", "no-cache")
+      |> send_resp(200, "event: message\ndata: #{data}\n\n")
+    else
+      json(conn, payload)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Tool dispatcher
+  # ---------------------------------------------------------------------------
+
+  defp dispatch("get_today", _args) do
+    %{today: Date.to_iso8601(Clock.today())}
+  end
+
+  defp dispatch("list_items", %{"date" => date_str}) do
+    with {:ok, date} <- Date.from_iso8601(date_str) do
+      Lists.get_items_for_date(date) |> Enum.map(&ItemJSON.item/1)
+    end
+  end
+
+  defp dispatch("list_items_range", args) do
+    with {:ok, from} <- Date.from_iso8601(args["from"]),
+         {:ok, to} <- Date.from_iso8601(args["to"]) do
+      statuses = args["statuses"] && Enum.map(args["statuses"], &String.to_existing_atom/1)
+      Lists.get_items_for_range(from, to, statuses) |> Enum.map(&ItemJSON.item/1)
+    end
+  end
+
+  defp dispatch("add_item", %{"date" => date_str, "body" => body}) do
+    with {:ok, date} <- Date.from_iso8601(date_str),
+         {:ok, [item]} <- Lists.create_items(date, [%{body: body}]) do
+      ItemJSON.item(item)
+    end
+  end
+
+  defp dispatch("update_item", %{"id" => id} = args) do
+    attrs = Map.drop(args, ["id"])
+
+    with {:ok, item} <- fetch_item(id),
+         {:ok, updated} <- Lists.update_item(item, attrs) do
+      ItemJSON.item(updated)
+    end
+  end
+
+  defp dispatch("arrow_item", %{"id" => id, "target_date" => target_date_str}) do
+    with {:ok, item} <- fetch_item(id),
+         {:ok, target_date} <- DateHelper.resolve(target_date_str),
+         {:ok, original, _copy} <- Lists.arrow_item(item, target_date) do
+      ItemJSON.item(original)
+    end
+  end
+
+  defp dispatch("search_items", %{"query" => query}) do
+    SearchIndex.search(query)
+    |> Enum.map(fn {id, date, body} ->
+      %{id: id, date: Date.to_iso8601(date), body: body}
+    end)
+  end
+
+  defp dispatch(_name, _args) do
+    %{error: "unknown tool"}
+  end
+
+  # ---------------------------------------------------------------------------
+  # Tool schema definitions
+  # ---------------------------------------------------------------------------
+
+  defp tool_definitions do
+    [
+      %{
+        name: "get_today",
+        description: "Get the current date in the user's local timezone (America/Denver)",
+        inputSchema: %{type: "object", properties: %{}, required: []}
+      },
+      %{
+        name: "list_items",
+        description: "Get all items for a specific date",
+        inputSchema: %{
+          type: "object",
+          properties: %{
+            date: %{type: "string", description: "ISO 8601 date, e.g. 2026-05-04"}
+          },
+          required: ["date"]
+        }
+      },
+      %{
+        name: "list_items_range",
+        description: "Get items across a date range, optionally filtered by status",
+        inputSchema: %{
+          type: "object",
+          properties: %{
+            from: %{type: "string", description: "Start date ISO 8601"},
+            to: %{type: "string", description: "End date ISO 8601"},
+            statuses: %{
+              type: "array",
+              items: %{type: "string", enum: ["active", "completed", "wiggled_out", "arrowed_out"]},
+              description: "Filter by these statuses (omit for all)"
+            }
+          },
+          required: ["from", "to"]
+        }
+      },
+      %{
+        name: "add_item",
+        description: "Add a new item to a date's list",
+        inputSchema: %{
+          type: "object",
+          properties: %{
+            date: %{type: "string", description: "ISO 8601 date"},
+            body: %{type: "string", description: "Item text"}
+          },
+          required: ["date", "body"]
+        }
+      },
+      %{
+        name: "update_item",
+        description: "Edit an existing item's body, status, color, or priority",
+        inputSchema: %{
+          type: "object",
+          properties: %{
+            id: %{type: "integer", description: "Item ID"},
+            body: %{type: "string"},
+            status: %{
+              type: "string",
+              enum: ["active", "completed", "wiggled_out"]
+            },
+            color: %{type: "string", enum: ListItem.color_strings()},
+            priority: %{type: "string", enum: ListItem.priorities()}
+          },
+          required: ["id"]
+        }
+      },
+      %{
+        name: "arrow_item",
+        description: "Move an active item forward to another date",
+        inputSchema: %{
+          type: "object",
+          properties: %{
+            id: %{type: "integer", description: "Item ID"},
+            target_date: %{type: "string", description: "ISO 8601 target date, or 'tomorrow'"}
+          },
+          required: ["id", "target_date"]
+        }
+      },
+      %{
+        name: "search_items",
+        description: "Full-text search across all items",
+        inputSchema: %{
+          type: "object",
+          properties: %{
+            query: %{type: "string", description: "Search query"}
+          },
+          required: ["query"]
+        }
+      }
+    ]
+  end
+
+  # ---------------------------------------------------------------------------
+  # Helpers
+  # ---------------------------------------------------------------------------
+
+  defp fetch_item(id), do: Helpers.fetch_item(id)
+end
diff --git a/lib/elixdo_web/controllers/health_controller.ex b/lib/elixdo_web/controllers/health_controller.ex
index 8272b6e..6cb6121 100644
--- a/lib/elixdo_web/controllers/health_controller.ex
+++ b/lib/elixdo_web/controllers/health_controller.ex
@@ -1,4 +1,5 @@
 defmodule ElixdoWeb.HealthController do
+  @moduledoc false
   use ElixdoWeb, :controller
 
   def show(conn, _params) do
diff --git a/lib/elixdo_web/controllers/manifest_controller.ex b/lib/elixdo_web/controllers/manifest_controller.ex
index fc9f096..1f1a8c3 100644
--- a/lib/elixdo_web/controllers/manifest_controller.ex
+++ b/lib/elixdo_web/controllers/manifest_controller.ex
@@ -1,4 +1,5 @@
 defmodule ElixdoWeb.ManifestController do
+  @moduledoc false
   use ElixdoWeb, :controller
 
   def show(conn, _params) do
diff --git a/lib/elixdo_web/controllers/page_controller.ex b/lib/elixdo_web/controllers/page_controller.ex
index e82d6ca..428502a 100644
--- a/lib/elixdo_web/controllers/page_controller.ex
+++ b/lib/elixdo_web/controllers/page_controller.ex
@@ -1,4 +1,5 @@
 defmodule ElixdoWeb.PageController do
+  @moduledoc false
   use ElixdoWeb, :controller
 
   def index(conn, _params) do
diff --git a/lib/elixdo_web/live/list_live.ex b/lib/elixdo_web/live/list_live.ex
index 2ec2783..478a4c5 100644
--- a/lib/elixdo_web/live/list_live.ex
+++ b/lib/elixdo_web/live/list_live.ex
@@ -1,7 +1,8 @@
 defmodule ElixdoWeb.ListLive do
+  @moduledoc false
   use ElixdoWeb, :live_view
 
-  alias Elixdo.{Lists, DateHelper, Emoji}
+  alias Elixdo.{Lists, DateHelper, ListItem}
 
   @impl true
   def mount(%{"secret" => secret} = params, _session, socket) do
@@ -37,7 +38,12 @@ defmodule ElixdoWeb.ListLive do
      |> assign(:arrow_item_ids, [])
      |> assign(:search_open, false)
      |> assign(:search_results, [])
-     |> assign(:highlighted_item_id, nil)}
+     |> assign(:highlighted_item_id, nil)
+     |> assign(:color_sheet_open, false)
+     |> assign(:last_color, :blue)
+     |> assign(:priority_sheet_open, false)
+     |> assign(:valid_colors, ListItem.colors())
+     |> assign(:valid_priorities, ListItem.priorities())}
   end
 
   @impl true
@@ -117,15 +123,20 @@ defmodule ElixdoWeb.ListLive do
     {:noreply, socket |> assign(:selected, selected) |> assign(:highlighted_item_id, nil)}
   end
 
-  def handle_event("toggle_all", _, socket) do
-    all_ids = socket.assigns.items |> Enum.map(& &1.id) |> MapSet.new()
-    selected = if socket.assigns.selected == all_ids, do: MapSet.new(), else: all_ids
-    {:noreply, assign(socket, :selected, selected)}
+  # Voice input
+  def handle_event("voice_input", %{"text" => text}, socket) do
+    text = String.trim(text)
+
+    if text != "" do
+      Lists.create_items(socket.assigns.date, [%{body: text}])
+    end
+
+    {:noreply, socket}
   end
 
   # Add item
   def handle_event("add_item", %{"body" => body}, socket) do
-    body = body |> String.trim() |> Emoji.convert()
+    body = String.trim(body)
 
     if body != "" do
       Lists.create_items(socket.assigns.date, [%{body: body}])
@@ -147,7 +158,7 @@ defmodule ElixdoWeb.ListLive do
 
   def handle_event("save_edit", %{"_id" => id, "body" => body}, socket) do
     id = String.to_integer(id)
-    body = body |> String.trim() |> Emoji.convert()
+    body = String.trim(body)
 
     if body != "" do
       item = Enum.find(socket.assigns.items, &(&1.id == id))
@@ -166,39 +177,53 @@ defmodule ElixdoWeb.ListLive do
   @valid_statuses Ecto.Enum.values(Elixdo.ListItem, :status)
   @valid_status_strings Enum.map(@valid_statuses, &Atom.to_string/1)
 
-  @valid_colors Ecto.Enum.values(Elixdo.ListItem, :color)
-  @valid_color_strings Enum.map(@valid_colors, &Atom.to_string/1)
+  @valid_color_strings ListItem.color_strings()
+
+  @valid_priorities ListItem.priorities()
+
+  def handle_event("open_priority_sheet", _, socket) do
+    {:noreply, assign(socket, :priority_sheet_open, true)}
+  end
+
+  def handle_event("close_priority_sheet", _, socket) do
+    {:noreply, assign(socket, :priority_sheet_open, false)}
+  end
+
+  def handle_event("set_priority", %{"priority" => p}, socket)
+      when p in @valid_priorities do
+    selected_items = selected_items(socket)
+
+    Enum.each(selected_items, fn item ->
+      Lists.update_item(item, %{priority: p})
+    end)
+
+    {:noreply, socket |> assign(:priority_sheet_open, false) |> clear_selection()}
+  end
 
   def handle_event("set_status", %{"status" => status_str}, socket)
       when status_str in @valid_status_strings do
     status = String.to_existing_atom(status_str)
 
-    selected_items =
-      Enum.filter(socket.assigns.items, &MapSet.member?(socket.assigns.selected, &1.id))
+    selected_items = selected_items(socket)
 
     Enum.each(selected_items, fn item ->
       Lists.update_item(item, %{status: status})
     end)
 
-    {:noreply, socket}
+    {:noreply, clear_selection(socket)}
   end
 
   def handle_event("set_status", _, socket), do: {:noreply, socket}
 
   # Toolbar decoration actions
   def handle_event("set_decoration", %{"field" => field, "setting" => setting}, socket) do
-    selected_items =
-      Enum.filter(socket.assigns.items, &MapSet.member?(socket.assigns.selected, &1.id))
+    selected_items = selected_items(socket)
 
     attrs =
       case field do
-        "bold" -> %{bold: setting == "true"}
-        "italic" -> %{italic: setting == "true"}
-        "highlighted" -> %{highlighted: setting == "true"}
         "color" when setting == "" -> %{color: nil}
         "color" when setting in @valid_color_strings -> %{color: String.to_existing_atom(setting)}
         "color" -> %{}
-        "prefix" -> %{prefix: if(setting == "", do: nil, else: setting)}
         _ -> %{}
       end
 
@@ -206,19 +231,54 @@ defmodule ElixdoWeb.ListLive do
       Lists.update_item(item, attrs)
     end)
 
-    {:noreply, socket}
+    {:noreply, clear_selection(socket)}
+  end
+
+  # Mobile color sheet
+  def handle_event("open_color_sheet", _, socket) do
+    {:noreply, assign(socket, :color_sheet_open, true)}
+  end
+
+  def handle_event("close_color_sheet", _, socket) do
+    {:noreply, assign(socket, :color_sheet_open, false)}
+  end
+
+  def handle_event("set_color", %{"color" => color_str}, socket)
+      when color_str in @valid_color_strings do
+    color = String.to_existing_atom(color_str)
+
+    selected_items = selected_items(socket)
+
+    Enum.each(selected_items, fn item ->
+      Lists.update_item(item, %{color: color})
+    end)
+
+    {:noreply,
+     socket
+     |> assign(:color_sheet_open, false)
+     |> assign(:last_color, color)
+     |> clear_selection()
+    }
+  end
+
+  def handle_event("set_color", _, socket) do
+    {:noreply, assign(socket, :color_sheet_open, false)}
   end
 
   # Remove all formats + restore active status (except arrowed_out, which cannot transition)
   def handle_event("remove_formats", _, socket) do
-    selected_items =
-      Enum.filter(socket.assigns.items, &MapSet.member?(socket.assigns.selected, &1.id))
+    selected_items = selected_items(socket)
 
     Enum.each(selected_items, fn item ->
-      Lists.update_item(item, %{bold: false, italic: false, highlighted: false, color: nil, status: :active, arrowed_to_date: nil})
+      Lists.update_item(item, %{
+        color: nil,
+        priority: nil,
+        status: :active,
+        arrowed_to_date: nil
+      })
     end)
 
-    {:noreply, socket}
+    {:noreply, clear_selection(socket)}
   end
 
   # Arrow-out flow
@@ -265,6 +325,15 @@ defmodule ElixdoWeb.ListLive do
     {:noreply, socket}
   end
 
+  def handle_event("sort_active", _, socket) do
+    {active, non_active} =
+      Enum.split_with(socket.assigns.items, &(&1.status == :active))
+
+    new_ids = Enum.map(active ++ non_active, & &1.id)
+    Lists.reorder_items(socket.assigns.date, new_ids)
+    {:noreply, socket}
+  end
+
   # Search
   def handle_event("open_search", _, socket) do
     {:noreply, assign(socket, search_open: true, search_results: [])}
@@ -315,19 +384,19 @@ defmodule ElixdoWeb.ListLive do
     ~p"/#{secret}/list/#{Date.to_iso8601(date)}"
   end
 
+  defp clear_selection(socket), do: assign(socket, :selected, MapSet.new())
+
+  defp selected_items(socket) do
+    Enum.filter(socket.assigns.items, &MapSet.member?(socket.assigns.selected, &1.id))
+  end
+
   defp item_class(%{status: :completed}), do: "completed"
   defp item_class(%{status: :wiggled_out}), do: "wiggled-out"
   defp item_class(%{status: :arrowed_out}), do: "arrowed-out"
   defp item_class(_), do: "active"
 
   defp item_classes(item) do
-    [
-      item_class(item),
-      if(item.bold, do: "bold", else: nil),
-      if(item.italic, do: "italic", else: nil),
-      if(item.highlighted, do: "highlighted", else: nil),
-      color_class(item.color)
-    ]
+    [item_class(item), color_class(item.color)]
     |> Enum.reject(&is_nil/1)
     |> Enum.join(" ")
   end
diff --git a/lib/elixdo_web/live/list_live.html.heex b/lib/elixdo_web/live/list_live.html.heex
index 14aeea4..1f60fba 100644
--- a/lib/elixdo_web/live/list_live.html.heex
+++ b/lib/elixdo_web/live/list_live.html.heex
@@ -2,10 +2,10 @@
   <div class="list-container" id="list-live" phx-hook="Swipe">
     <div class="toolbar" id="toolbar">
       <div class="toolbar-left">
-        <% all_selected? = @items != [] and MapSet.size(@selected) == length(@items) %>
-        <%# Select-all — ring circle, no text content %>
-        <button type="button" phx-click="toggle_all" title="Select all"
-                class={"select-btn #{if all_selected?, do: "selected", else: ""}"}></button>
+        <%# Go to today — only shown when not on today %>
+        <%= if @date != @today do %>
+          <button type="button" phx-click="go_today" class="today-btn" title="Goto Today">◉</button>
+        <% end %>
 
         <%# Search — SVG magnifier %>
         <button type="button" phx-click="open_search" class="search-btn" title="Search">
@@ -14,6 +14,16 @@
             <line x1="11.5" y1="11.5" x2="16" y2="16"/>
           </svg>
         </button>
+
+        <%# Sort active-first %>
+        <button type="button" phx-click="sort_active" class="sort-btn" title="Sort by status">
+          <svg width="18" height="18" viewBox="0 0 18 18" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
+            <line x1="5" y1="2" x2="5" y2="16"/>
+            <polyline points="2,5 5,2 8,5"/>
+            <line x1="13" y1="2" x2="13" y2="16"/>
+            <polyline points="10,13 13,16 16,13"/>
+          </svg>
+        </button>
       </div>
 
       <div class="toolbar-actions">
@@ -44,34 +54,25 @@
           </button>
         </div>
 
-        <%# ── Style group ───────────────────────────────────────── %>
-        <div class="tb-group">
-          <button type="button" phx-click="set_decoration" phx-value-field="bold"
-                  phx-value-setting="true" class="toolbar-btn" title="Bold">
-            <b>B</b>
-          </button>
-          <button type="button" phx-click="set_decoration" phx-value-field="italic"
-                  phx-value-setting="true" class="toolbar-btn" title="Italic">
-            <i>I</i>
-          </button>
-          <button type="button" phx-click="set_decoration" phx-value-field="highlighted"
-                  phx-value-setting="true" class="toolbar-btn" title="Highlight">
-            <span style="background:oklch(85% 0.16 90 / 0.5);border-radius:3px;padding:2px 6px;font-size:19px;font-weight:800;color:oklch(90% 0.12 90)">H</span>
-          </button>
+        <%# ── Priority handle decorations ───────────────────────── %>
+        <button type="button" phx-click="open_priority_sheet"
+                class="priority-mobile-btn toolbar-btn" title="Priority">⭐</button>
+        <div class="tb-group priority-desktop-group">
+          <%= for p <- @valid_priorities do %>
+            <button type="button" phx-click="set_priority" phx-value-priority={p}
+                    class="toolbar-btn priority-btn" title={"Priority #{p}"}>{p}</button>
+          <% end %>
         </div>
 
-        <%# ── Color swatches ────────────────────────────────────── %>
+        <%# ── Color swatches (desktop) + mobile trigger ─────────── %>
+        <button type="button" phx-click="open_color_sheet"
+                class={"color-mobile-btn swatch-#{@last_color}"} title="Color"></button>
         <div class="swatches-row">
-          <button type="button" phx-click="set_decoration" phx-value-field="color"
-                  phx-value-setting="red" class="color-swatch swatch-red" title="Red"></button>
-          <button type="button" phx-click="set_decoration" phx-value-field="color"
-                  phx-value-setting="blue" class="color-swatch swatch-blue" title="Blue"></button>
-          <button type="button" phx-click="set_decoration" phx-value-field="color"
-                  phx-value-setting="green" class="color-swatch swatch-green" title="Green"></button>
-          <button type="button" phx-click="set_decoration" phx-value-field="color"
-                  phx-value-setting="purple" class="color-swatch swatch-purple" title="Purple"></button>
-          <button type="button" phx-click="set_decoration" phx-value-field="color"
-                  phx-value-setting="orange" class="color-swatch swatch-orange" title="Orange"></button>
+          <%= for color <- @valid_colors do %>
+            <button type="button" phx-click="set_decoration" phx-value-field="color"
+                    phx-value-setting={color} class={"color-swatch swatch-#{color}"}
+                    title={String.capitalize(Atom.to_string(color))}></button>
+          <% end %>
         </div>
 
         <%# ── Clear formats ─────────────────────────────────────── %>
@@ -84,24 +85,15 @@
           </button>
         </div>
 
-        <%# ── Prefix input ──────────────────────────────────────── %>
-        <form phx-submit="set_decoration" class="prefix-form">
-          <input type="hidden" name="field" value="prefix" />
-          <input type="text" name="setting" placeholder="pfx" class="prefix-input" maxlength="3" />
-        </form>
-
       </div>
 
-      <%= if @date != @today do %>
-        <button type="button" phx-click="go_today" class="today-btn">Today</button>
-      <% end %>
     </div>
 
     <%# ── Date header ───────────────────────────────────────────── %>
     <div class="date-header">
       <button type="button" phx-click="prev_day" class="nav-arrow nav-left">⟨</button>
       <div class="date-display">
-        <label for="date-picker">{Calendar.strftime(@date, "%A, %B %-d, %Y")}</label>
+        <label for="date-picker">{Calendar.strftime(@date, "%A, %B %-d")}</label>
         <%# Custom styled date picker: button triggers showPicker() on hidden input %>
         <div class="date-picker-wrap">
           <button type="button" class="date-picker-btn" onclick="document.getElementById('date-picker').showPicker()">
@@ -134,7 +126,7 @@
           class={["item", item_class(item), color_item_class(item), if(@highlighted_item_id == item.id, do: "search-highlight")] |> Enum.reject(&is_nil/1) |> Enum.join(" ")}
           data-id={item.id}
         >
-          <span class="drag-handle">⠿</span>
+          <span class={["drag-handle", item.priority && "drag-handle--priority"]}>{item.priority || "⠿"}</span>
 
           <%# Per-item select circle — no text, uses CSS ::after for fill dot %>
           <button
@@ -145,10 +137,6 @@
             title={if MapSet.member?(@selected, item.id), do: "Deselect", else: "Select"}
           ></button>
 
-          <%= if item.prefix do %>
-            <span class="prefix-badge">{item.prefix}</span>
-          <% end %>
-
           <%= if @editing_id == item.id do %>
             <form phx-submit="save_edit" class="edit-form">
               <input type="hidden" name="_id" value={item.id} />
@@ -169,12 +157,20 @@
     <form phx-submit="add_item" class="add-item-form">
       <textarea
         name="body"
-        placeholder="Add item… (Enter to save, Shift+Enter for newline)"
+        placeholder="New task..."
         phx-hook="AddItem"
         id="add-item-input"
         class="add-item-input"
         rows="2"
       ></textarea>
+      <button type="button" id="mic-btn" phx-hook="VoiceInput" phx-update="ignore" class="mic-btn" title="Voice input" style="display:none">
+        <svg width="20" height="20" viewBox="0 0 20 20" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <rect x="7" y="1" width="6" height="10" rx="3"/>
+          <path d="M3 10a7 7 0 0 0 14 0"/>
+          <line x1="10" y1="17" x2="10" y2="20"/>
+          <line x1="7" y1="20" x2="13" y2="20"/>
+        </svg>
+      </button>
       <button type="submit" class="add-btn">Add</button>
     </form>
   </div>
@@ -193,6 +189,30 @@
     </div>
   <% end %>
 
+  <%# ── Priority bottom sheet (mobile) ──────────────────────────────── %>
+  <%= if @priority_sheet_open do %>
+    <div class="bottom-sheet-overlay" phx-click="close_priority_sheet">
+      <div class="bottom-sheet">
+        <%= for p <- @valid_priorities do %>
+          <button type="button" phx-click="set_priority" phx-value-priority={p}
+                  class="priority-sheet-btn" title={"Priority #{p}"}>{p}</button>
+        <% end %>
+      </div>
+    </div>
+  <% end %>
+
+  <%# ── Color bottom sheet (mobile) ─────────────────────────────────── %>
+  <%= if @color_sheet_open do %>
+    <div class="bottom-sheet-overlay" phx-click="close_color_sheet">
+      <div class="bottom-sheet">
+        <%= for color <- @valid_colors do %>
+          <button type="button" phx-click="set_color" phx-value-color={color}
+                  class={"color-sheet-swatch swatch-#{color}"}></button>
+        <% end %>
+      </div>
+    </div>
+  <% end %>
+
   <%# ── Search modal ───────────────────────────────────────────────── %>
   <%= if @search_open do %>
     <div class="modal-overlay">
diff --git a/lib/elixdo_web/plugs/api_auth_plug.ex b/lib/elixdo_web/plugs/api_auth_plug.ex
index 39bfa0e..6bf8a2a 100644
--- a/lib/elixdo_web/plugs/api_auth_plug.ex
+++ b/lib/elixdo_web/plugs/api_auth_plug.ex
@@ -16,7 +16,10 @@ defmodule ElixdoWeb.ApiAuthPlug do
       _ ->
         conn
         |> put_resp_content_type("application/json")
-        |> send_resp(401, Jason.encode!(%{error: %{code: "unauthorized", message: "Invalid or missing token"}}))
+        |> send_resp(
+          401,
+          Jason.encode!(%{error: %{code: "unauthorized", message: "Invalid or missing token"}})
+        )
         |> halt()
     end
   end
diff --git a/lib/elixdo_web/router.ex b/lib/elixdo_web/router.ex
index a74b2b9..c350fb9 100644
--- a/lib/elixdo_web/router.ex
+++ b/lib/elixdo_web/router.ex
@@ -20,6 +20,11 @@ defmodule ElixdoWeb.Router do
     plug ElixdoWeb.ApiAuthPlug
   end
 
+  # MCP handles its own content negotiation (JSON and SSE), so no :accepts plug here
+  pipeline :mcp_auth do
+    plug ElixdoWeb.ApiAuthPlug
+  end
+
   scope "/" do
     pipe_through :api
     get "/manifest.json", ElixdoWeb.ManifestController, :show
@@ -37,6 +42,11 @@ defmodule ElixdoWeb.Router do
     post "/items/:id/arrow", ItemController, :arrow
   end
 
+  scope "/api/v1", ElixdoWeb.Api do
+    pipe_through :mcp_auth
+    post "/mcp", McpController, :handle
+  end
+
   scope "/:secret", ElixdoWeb do
     pipe_through :browser
     get "/", PageController, :index
diff --git a/priv/repo/migrations/20260504213717_drop_prefix_from_list_items.exs b/priv/repo/migrations/20260504213717_drop_prefix_from_list_items.exs
new file mode 100644
index 0000000..2cd43b7
--- /dev/null
+++ b/priv/repo/migrations/20260504213717_drop_prefix_from_list_items.exs
@@ -0,0 +1,15 @@
+defmodule Elixdo.Repo.Migrations.DropPrefixFromListItems do
+  use Ecto.Migration
+
+  def up do
+    alter table(:list_items) do
+      remove :prefix
+    end
+  end
+
+  def down do
+    alter table(:list_items) do
+      add :prefix, :string
+    end
+  end
+end
diff --git a/priv/repo/migrations/20260504214315_drop_bold_italic_highlighted_from_list_items.exs b/priv/repo/migrations/20260504214315_drop_bold_italic_highlighted_from_list_items.exs
new file mode 100644
index 0000000..8566585
--- /dev/null
+++ b/priv/repo/migrations/20260504214315_drop_bold_italic_highlighted_from_list_items.exs
@@ -0,0 +1,19 @@
+defmodule Elixdo.Repo.Migrations.DropBoldItalicHighlightedFromListItems do
+  use Ecto.Migration
+
+  def up do
+    alter table(:list_items) do
+      remove :bold
+      remove :italic
+      remove :highlighted
+    end
+  end
+
+  def down do
+    alter table(:list_items) do
+      add :bold, :boolean, null: false, default: false
+      add :italic, :boolean, null: false, default: false
+      add :highlighted, :boolean, null: false, default: false
+    end
+  end
+end
diff --git a/priv/repo/migrations/20260504215723_add_priority_to_list_items.exs b/priv/repo/migrations/20260504215723_add_priority_to_list_items.exs
new file mode 100644
index 0000000..d3ae3d4
--- /dev/null
+++ b/priv/repo/migrations/20260504215723_add_priority_to_list_items.exs
@@ -0,0 +1,9 @@
+defmodule Elixdo.Repo.Migrations.AddPriorityToListItems do
+  use Ecto.Migration
+
+  def change do
+    alter table(:list_items) do
+      add :priority, :string
+    end
+  end
+end
diff --git a/test/elixdo/list_item_priority_test.exs b/test/elixdo/list_item_priority_test.exs
new file mode 100644
index 0000000..4eebc73
--- /dev/null
+++ b/test/elixdo/list_item_priority_test.exs
@@ -0,0 +1,39 @@
+defmodule Elixdo.ListItemPriorityTest do
+  use Elixdo.DataCase, async: false
+
+  alias Elixdo.{ListItem, Lists}
+
+  @valid_priorities ["❶", "❷", "❸", "🔥", "⭐"]
+  @date ~D[2026-08-01]
+
+  describe "ListItem.changeset/2 priority validation" do
+    test "accepts nil priority" do
+      attrs = %{date: @date, position: 1, body: "item", priority: nil}
+      changeset = ListItem.changeset(%ListItem{}, attrs)
+      assert changeset.valid?
+    end
+
+    test "accepts each valid priority character" do
+      for p <- @valid_priorities do
+        attrs = %{date: @date, position: 1, body: "item", priority: p}
+        changeset = ListItem.changeset(%ListItem{}, attrs)
+        assert changeset.valid?, "expected #{p} to be valid"
+      end
+    end
+
+    test "rejects an invalid priority character" do
+      attrs = %{date: @date, position: 1, body: "item", priority: "X"}
+      changeset = ListItem.changeset(%ListItem{}, attrs)
+      refute changeset.valid?
+      assert %{priority: [_ | _]} = errors_on(changeset)
+    end
+  end
+
+  describe "arrow_item/2 priority handling" do
+    test "arrow copy does not inherit priority" do
+      {:ok, [item]} = Lists.create_items(@date, [%{body: "important", priority: "🔥"}])
+      {:ok, _original, copy} = Lists.arrow_item(item, ~D[2026-08-02])
+      assert copy.priority == nil
+    end
+  end
+end
diff --git a/test/elixdo/lists_test.exs b/test/elixdo/lists_test.exs
index c42d52e..803d115 100644
--- a/test/elixdo/lists_test.exs
+++ b/test/elixdo/lists_test.exs
@@ -148,23 +148,26 @@ defmodule Elixdo.ListsTest do
     end
 
     test "allows same-status no-op active -> active (so format fields can be cleared)" do
-      item = insert_item(%{bold: true})
-      assert {:ok, updated} = Lists.update_item(item, %{status: :active, bold: false})
+      item = insert_item(%{color: :red})
+      assert {:ok, updated} = Lists.update_item(item, %{status: :active, color: nil})
       assert updated.status == :active
-      assert updated.bold == false
+      assert updated.color == nil
     end
 
     test "forbids invalid transition completed -> completed" do
       item = insert_item()
       {:ok, completed} = Lists.update_item(item, %{status: :completed})
-      assert {:ok, updated} = Lists.update_item(completed, %{status: :completed, bold: false})
+      assert {:ok, updated} = Lists.update_item(completed, %{status: :completed, color: nil})
       assert updated.status == :completed
     end
 
     test "allows arrowed_out -> active (remove formats undoes arrow)" do
       item = insert_item()
       {:ok, arrowed, _copy} = Lists.arrow_item(item, ~D[2026-09-01])
-      assert {:ok, restored} = Lists.update_item(arrowed, %{status: :active, arrowed_to_date: nil})
+
+      assert {:ok, restored} =
+               Lists.update_item(arrowed, %{status: :active, arrowed_to_date: nil})
+
       assert restored.status == :active
       assert restored.arrowed_to_date == nil
     end
@@ -183,18 +186,19 @@ defmodule Elixdo.ListsTest do
     end
 
     test "allows clearing arrowed_to_date together with status: active (remove formats path)" do
-      item = insert_item(%{bold: true, italic: true})
+      item = insert_item(%{color: :blue})
       {:ok, arrowed, _copy} = Lists.arrow_item(item, ~D[2026-09-01])
+
       assert {:ok, restored} =
                Lists.update_item(arrowed, %{
                  status: :active,
                  arrowed_to_date: nil,
-                 bold: false,
-                 italic: false
+                 color: nil
                })
+
       assert restored.status == :active
       assert restored.arrowed_to_date == nil
-      assert restored.bold == false
+      assert restored.color == nil
     end
 
     test "forbids arrowed_out -> completed" do
@@ -221,21 +225,10 @@ defmodule Elixdo.ListsTest do
       assert copy.status == :active
     end
 
-    test "preserves item formatting on copy" do
-      {:ok, [item]} =
-        Lists.create_items(@date, [
-          %{
-            body: "formatted",
-            bold: true,
-            italic: true,
-            highlighted: true
-          }
-        ])
-
+    test "preserves color on copy" do
+      {:ok, [item]} = Lists.create_items(@date, [%{body: "colored", color: :green}])
       assert {:ok, _original, copy} = Lists.arrow_item(item, @date2)
-      assert copy.bold == true
-      assert copy.italic == true
-      assert copy.highlighted == true
+      assert copy.color == :green
     end
 
     test "forbids arrow on completed item" do
diff --git a/test/elixdo_web/controllers/api/item_json_priority_test.exs b/test/elixdo_web/controllers/api/item_json_priority_test.exs
new file mode 100644
index 0000000..d05ca32
--- /dev/null
+++ b/test/elixdo_web/controllers/api/item_json_priority_test.exs
@@ -0,0 +1,21 @@
+defmodule ElixdoWeb.Api.ItemJSONPriorityTest do
+  use Elixdo.DataCase, async: false
+
+  alias ElixdoWeb.Api.ItemJSON
+  alias Elixdo.Lists
+
+  @date ~D[2026-08-01]
+
+  test "ItemJSON includes priority field when nil" do
+    {:ok, [item]} = Lists.create_items(@date, [%{body: "no priority"}])
+    result = ItemJSON.item(item)
+    assert Map.has_key?(result, :priority)
+    assert result.priority == nil
+  end
+
+  test "ItemJSON includes priority field when set" do
+    {:ok, [item]} = Lists.create_items(@date, [%{body: "has priority", priority: "❶"}])
+    result = ItemJSON.item(item)
+    assert result.priority == "❶"
+  end
+end
diff --git a/test/elixdo_web/controllers/api/list_controller_test.exs b/test/elixdo_web/controllers/api/list_controller_test.exs
index 17d84e5..2b74495 100644
--- a/test/elixdo_web/controllers/api/list_controller_test.exs
+++ b/test/elixdo_web/controllers/api/list_controller_test.exs
@@ -81,11 +81,7 @@ defmodule ElixdoWeb.Api.ListControllerTest do
       assert result["body"] == "test item"
       assert result["status"] == "active"
       assert result["position"] == 1
-      assert result["bold"] == false
-      assert result["italic"] == false
-      assert result["highlighted"] == false
       assert result["color"] == nil
-      assert result["prefix"] == nil
       assert result["arrowed_to_date"] == nil
       assert String.ends_with?(result["inserted_at"], "Z")
       assert String.ends_with?(result["updated_at"], "Z")
diff --git a/test/elixdo_web/controllers/api/mcp_controller_test.exs b/test/elixdo_web/controllers/api/mcp_controller_test.exs
new file mode 100644
index 0000000..eaee88c
--- /dev/null
+++ b/test/elixdo_web/controllers/api/mcp_controller_test.exs
@@ -0,0 +1,315 @@
+defmodule ElixdoWeb.Api.McpControllerTest do
+  use ElixdoWeb.ConnCase, async: false
+  import Mox
+
+  alias Elixdo.Lists
+
+  setup :verify_on_exit!
+
+  # November 2026 dates — safe from collision per test_date_uniqueness_test.exs
+  @date ~D[2026-11-10]
+  @arrow_target ~D[2026-11-11]
+
+  @token "test-agent-token"
+
+  setup do
+    Mox.stub(Elixdo.Clock.Mock, :today, fn -> ~D[2026-11-01] end)
+    System.put_env("AGENT_TOKEN", @token)
+    on_exit(fn -> System.delete_env("AGENT_TOKEN") end)
+    :ok
+  end
+
+  defp auth_conn(conn) do
+    conn
+    |> put_req_header("authorization", "Bearer #{@token}")
+    |> put_req_header("content-type", "application/json")
+  end
+
+  defp mcp(conn, method, params \\ %{}, id \\ 1) do
+    body = Jason.encode!(%{jsonrpc: "2.0", id: id, method: method, params: params})
+    conn |> auth_conn() |> post("/api/v1/mcp", body)
+  end
+
+  defp insert_item(attrs \\ []) do
+    attrs = Enum.into(attrs, %{})
+    {:ok, [item]} = Lists.create_items(attrs[:date] || @date, [Map.merge(%{body: "test item"}, attrs)])
+    item
+  end
+
+  # ---------------------------------------------------------------------------
+  # initialize
+  # ---------------------------------------------------------------------------
+
+  test "initialize returns correct protocol version and capabilities", %{conn: conn} do
+    resp = mcp(conn, "initialize") |> json_response(200)
+    assert resp["jsonrpc"] == "2.0"
+    assert resp["result"]["protocolVersion"] == "2024-11-05"
+    assert resp["result"]["serverInfo"]["name"] == "elixdo"
+    assert is_map(resp["result"]["capabilities"]["tools"])
+  end
+
+  # ---------------------------------------------------------------------------
+  # tools/list
+  # ---------------------------------------------------------------------------
+
+  test "tools/list returns all seven tool definitions with required fields", %{conn: conn} do
+    resp = mcp(conn, "tools/list") |> json_response(200)
+    tools = resp["result"]["tools"]
+    names = Enum.map(tools, & &1["name"]) |> MapSet.new()
+
+    assert MapSet.size(names) == 7
+    expected = ~w[get_today list_items list_items_range add_item update_item arrow_item search_items]
+    for name <- expected, do: assert MapSet.member?(names, name), message: "missing tool: #{name}"
+
+    for tool <- tools do
+      assert is_binary(tool["name"])
+      assert is_binary(tool["description"])
+      assert is_map(tool["inputSchema"])
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # tools/call — get_today
+  # ---------------------------------------------------------------------------
+
+  test "get_today returns today's date", %{conn: conn} do
+    resp = mcp(conn, "tools/call", %{"name" => "get_today", "arguments" => %{}}) |> json_response(200)
+    text = resp["result"]["content"] |> hd() |> Map.fetch!("text")
+    result = Jason.decode!(text)
+    assert result["today"] =~ ~r/^\d{4}-\d{2}-\d{2}$/
+  end
+
+  # ---------------------------------------------------------------------------
+  # tools/call — list_items
+  # ---------------------------------------------------------------------------
+
+  test "list_items returns items for a date", %{conn: conn} do
+    item = insert_item(date: @date, body: "mcp test item")
+
+    resp =
+      mcp(conn, "tools/call", %{
+        "name" => "list_items",
+        "arguments" => %{"date" => Date.to_iso8601(@date)}
+      })
+      |> json_response(200)
+
+    text = resp["result"]["content"] |> hd() |> Map.fetch!("text")
+    items = Jason.decode!(text)
+    assert Enum.any?(items, &(&1["id"] == item.id))
+  end
+
+  # ---------------------------------------------------------------------------
+  # tools/call — add_item
+  # ---------------------------------------------------------------------------
+
+  test "add_item creates item and it appears in list_items", %{conn: conn} do
+    date_str = "2026-11-12"
+
+    mcp(conn, "tools/call", %{
+      "name" => "add_item",
+      "arguments" => %{"date" => date_str, "body" => "added via mcp"}
+    })
+    |> json_response(200)
+
+    items = Lists.get_items_for_date(~D[2026-11-12])
+    assert Enum.any?(items, &(&1.body == "added via mcp"))
+  end
+
+  # ---------------------------------------------------------------------------
+  # tools/call — update_item
+  # ---------------------------------------------------------------------------
+
+  test "update_item changes item body", %{conn: conn} do
+    item = insert_item(date: @date)
+
+    mcp(conn, "tools/call", %{
+      "name" => "update_item",
+      "arguments" => %{"id" => item.id, "body" => "updated via mcp"}
+    })
+    |> json_response(200)
+
+    [updated] = Lists.get_items_for_date(@date) |> Enum.filter(&(&1.id == item.id))
+    assert updated.body == "updated via mcp"
+  end
+
+  # ---------------------------------------------------------------------------
+  # tools/call — arrow_item
+  # ---------------------------------------------------------------------------
+
+  test "arrow_item marks original arrowed_out and creates copy on target date", %{conn: conn} do
+    item = insert_item(date: @date)
+
+    mcp(conn, "tools/call", %{
+      "name" => "arrow_item",
+      "arguments" => %{"id" => item.id, "target_date" => Date.to_iso8601(@arrow_target)}
+    })
+    |> json_response(200)
+
+    original = Lists.get_items_for_date(@date) |> hd()
+    assert original.status == :arrowed_out
+
+    copies = Lists.get_items_for_date(@arrow_target)
+    assert Enum.any?(copies, &(&1.body == item.body))
+  end
+
+  # ---------------------------------------------------------------------------
+  # tools/call — search_items
+  # ---------------------------------------------------------------------------
+
+  test "search_items returns matching results", %{conn: conn} do
+    insert_item(date: @date, body: "uniquesearchterm2026")
+    # Give search index time to index
+    Process.sleep(50)
+
+    resp =
+      mcp(conn, "tools/call", %{
+        "name" => "search_items",
+        "arguments" => %{"query" => "uniquesearchterm2026"}
+      })
+      |> json_response(200)
+
+    text = resp["result"]["content"] |> hd() |> Map.fetch!("text")
+    results = Jason.decode!(text)
+    assert Enum.any?(results, &(&1["body"] =~ "uniquesearchterm2026"))
+  end
+
+  # ---------------------------------------------------------------------------
+  # Emoji shortcode conversion
+  # ---------------------------------------------------------------------------
+
+  test "add_item converts shortcodes in body", %{conn: conn} do
+    mcp(conn, "tools/call", %{
+      "name" => "add_item",
+      "arguments" => %{"date" => "2026-11-13", "body" => "buy :star: and :rocket:"}
+    })
+    |> json_response(200)
+
+    [item] = Lists.get_items_for_date(~D[2026-11-13])
+    assert item.body == "buy ⭐ and 🚀"
+  end
+
+  test "update_item converts shortcodes in body", %{conn: conn} do
+    item = insert_item(date: @date, body: "plain text")
+
+    mcp(conn, "tools/call", %{
+      "name" => "update_item",
+      "arguments" => %{"id" => item.id, "body" => "on :fire: today"}
+    })
+    |> json_response(200)
+
+    [updated] = Lists.get_items_for_date(@date) |> Enum.filter(&(&1.id == item.id))
+    assert updated.body == "on 🔥 today"
+  end
+
+  test "update_item without body field is unaffected by shortcode conversion", %{conn: conn} do
+    item = insert_item(date: @date, body: "no change")
+
+    mcp(conn, "tools/call", %{
+      "name" => "update_item",
+      "arguments" => %{"id" => item.id, "status" => "completed"}
+    })
+    |> json_response(200)
+
+    [updated] = Lists.get_items_for_date(@date) |> Enum.filter(&(&1.id == item.id))
+    assert updated.body == "no change"
+    assert updated.status == :completed
+  end
+
+  # ---------------------------------------------------------------------------
+  # list_items_range
+  # ---------------------------------------------------------------------------
+
+  test "list_items_range returns items across a date range", %{conn: conn} do
+    insert_item(date: ~D[2026-11-14], body: "day one")
+    insert_item(date: ~D[2026-11-15], body: "day two")
+    insert_item(date: ~D[2026-11-16], body: "outside range")
+
+    resp =
+      mcp(conn, "tools/call", %{
+        "name" => "list_items_range",
+        "arguments" => %{"from" => "2026-11-14", "to" => "2026-11-15"}
+      })
+      |> json_response(200)
+
+    text = resp["result"]["content"] |> hd() |> Map.fetch!("text")
+    items = Jason.decode!(text)
+    bodies = Enum.map(items, & &1["body"])
+    assert "day one" in bodies
+    assert "day two" in bodies
+    refute "outside range" in bodies
+  end
+
+  test "list_items_range with status filter returns only matching items", %{conn: conn} do
+    {:ok, [active]} = Lists.create_items(~D[2026-11-17], [%{body: "still active"}])
+    {:ok, [done]} = Lists.create_items(~D[2026-11-17], [%{body: "all done"}])
+    Lists.update_item(done, %{status: :completed})
+
+    resp =
+      mcp(conn, "tools/call", %{
+        "name" => "list_items_range",
+        "arguments" => %{"from" => "2026-11-17", "to" => "2026-11-17", "statuses" => ["active"]}
+      })
+      |> json_response(200)
+
+    text = resp["result"]["content"] |> hd() |> Map.fetch!("text")
+    items = Jason.decode!(text)
+    bodies = Enum.map(items, & &1["body"])
+    assert "still active" in bodies
+    refute "all done" in bodies
+    _ = active
+  end
+
+  # ---------------------------------------------------------------------------
+  # SSE (Streamable HTTP) transport
+  # ---------------------------------------------------------------------------
+
+  test "responds with SSE format when Accept: text/event-stream", %{conn: conn} do
+    body = Jason.encode!(%{jsonrpc: "2.0", id: 1, method: "initialize", params: %{}})
+
+    conn =
+      conn
+      |> put_req_header("authorization", "Bearer #{@token}")
+      |> put_req_header("content-type", "application/json")
+      |> put_req_header("accept", "text/event-stream")
+      |> post("/api/v1/mcp", body)
+
+    assert conn.status == 200
+    assert get_resp_header(conn, "content-type") |> hd() =~ "text/event-stream"
+    assert conn.resp_body =~ "event: message\ndata: "
+    payload = conn.resp_body |> String.split("data: ") |> List.last() |> String.trim()
+    decoded = Jason.decode!(payload)
+    assert decoded["result"]["protocolVersion"] == "2024-11-05"
+  end
+
+  # ---------------------------------------------------------------------------
+  # Notifications
+  # ---------------------------------------------------------------------------
+
+  test "notifications (no id) return 204 with empty body", %{conn: conn} do
+    body = Jason.encode!(%{jsonrpc: "2.0", method: "notifications/initialized", params: %{}})
+
+    conn =
+      conn
+      |> put_req_header("authorization", "Bearer #{@token}")
+      |> put_req_header("content-type", "application/json")
+      |> post("/api/v1/mcp", body)
+
+    assert conn.status == 204
+    assert conn.resp_body == ""
+  end
+
+  # ---------------------------------------------------------------------------
+  # Error cases
+  # ---------------------------------------------------------------------------
+
+  test "unknown method returns -32601 error", %{conn: conn} do
+    resp = mcp(conn, "not_a_real_method") |> json_response(200)
+    assert resp["error"]["code"] == -32601
+  end
+
+  test "missing auth returns 401", %{conn: conn} do
+    body = Jason.encode!(%{jsonrpc: "2.0", id: 1, method: "initialize", params: %{}})
+    resp = conn |> put_req_header("content-type", "application/json") |> post("/api/v1/mcp", body) |> json_response(401)
+    assert resp["error"]
+  end
+end
diff --git a/test/elixdo_web/live/list_live_color_sheet_test.exs b/test/elixdo_web/live/list_live_color_sheet_test.exs
new file mode 100644
index 0000000..17604ef
--- /dev/null
+++ b/test/elixdo_web/live/list_live_color_sheet_test.exs
@@ -0,0 +1,60 @@
+defmodule ElixdoWeb.ListLiveColorSheetTest do
+  use ElixdoWeb.ConnCase, async: false
+  import Phoenix.LiveViewTest
+  import Mox
+
+  setup :verify_on_exit!
+
+  setup do
+    Mox.stub(Elixdo.Clock.Mock, :today, fn -> ~D[2026-09-01] end)
+    :ok
+  end
+
+  defp secret, do: System.get_env("SECRET_PATH", "dev-secret")
+  defp list_path(date), do: "/#{secret()}/list/#{date}"
+
+  test "last_color defaults to blue at mount", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    assert view |> element(".color-mobile-btn.swatch-blue") |> has_element?()
+  end
+
+  test "open_color_sheet sets color_sheet_open: true", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    view |> element("[phx-click='open_color_sheet']") |> render_click()
+    assert render(view) =~ "bottom-sheet"
+  end
+
+  test "close_color_sheet sets color_sheet_open: false", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    view |> element("[phx-click='open_color_sheet']") |> render_click()
+    view |> element("[phx-click='close_color_sheet']") |> render_click()
+    refute render(view) =~ "bottom-sheet"
+  end
+
+  test "set_color applies color to selected items", %{conn: conn} do
+    date = ~D[2026-09-08]
+    {:ok, [item]} = Elixdo.Lists.create_items(date, [%{body: "colorful"}])
+
+    {:ok, view, _} = live(conn, list_path("2026-09-08"))
+    view |> element("[phx-click='toggle_select'][phx-value-id='#{item.id}']") |> render_click()
+    view |> element("[phx-click='open_color_sheet']") |> render_click()
+    view |> element("[phx-click='set_color'][phx-value-color='red']") |> render_click()
+
+    updated = Elixdo.Lists.get_items_for_date(date) |> hd()
+    assert updated.color == :red
+  end
+
+  test "set_color closes the sheet", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    view |> element("[phx-click='open_color_sheet']") |> render_click()
+    render_click(view, "set_color", %{"color" => "green"})
+    refute render(view) =~ "bottom-sheet"
+  end
+
+  test "set_color updates last_color assign", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    view |> element("[phx-click='open_color_sheet']") |> render_click()
+    render_click(view, "set_color", %{"color" => "purple"})
+    assert render(view) =~ "color-mobile-btn swatch-purple"
+  end
+end
diff --git a/test/elixdo_web/live/list_live_phase5_test.exs b/test/elixdo_web/live/list_live_phase5_test.exs
index 3e077bc..ce046d9 100644
--- a/test/elixdo_web/live/list_live_phase5_test.exs
+++ b/test/elixdo_web/live/list_live_phase5_test.exs
@@ -84,34 +84,6 @@ defmodule ElixdoWeb.ListLivePhase5Test do
     assert html =~ ~s(class="item wiggled-out")
   end
 
-  test "toggle_all selects every item, then deselects on second click", %{conn: conn} do
-    date = ~D[2026-05-20]
-    Elixdo.Lists.create_items(date, [%{body: "item a"}, %{body: "item b"}])
-
-    {:ok, view, _} = live(conn, list_path("2026-05-20"))
-    html = view |> element("[phx-click='toggle_all']") |> render_click()
-    assert html =~ ~s(class="select-btn selected")
-
-    html = view |> element("[phx-click='toggle_all']") |> render_click()
-    refute html =~ ~s(class="select-btn selected")
-  end
-
-  test "apply bold decoration to selected items", %{conn: conn} do
-    date = ~D[2026-05-21]
-    {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "make bold"}])
-    item = List.first(items)
-
-    {:ok, view, _} = live(conn, list_path("2026-05-21"))
-    view |> element("[phx-click='toggle_select'][phx-value-id='#{item.id}']") |> render_click()
-
-    view
-    |> element("[phx-click='set_decoration'][phx-value-field='bold'][phx-value-setting='true']")
-    |> render_click()
-
-    html = render(view)
-    assert html =~ "bold"
-  end
-
   test "apply color to selected items", %{conn: conn} do
     date = ~D[2026-05-22]
     {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "color me"}])
diff --git a/test/elixdo_web/live/list_live_phase7_test.exs b/test/elixdo_web/live/list_live_phase7_test.exs
new file mode 100644
index 0000000..209e9be
--- /dev/null
+++ b/test/elixdo_web/live/list_live_phase7_test.exs
@@ -0,0 +1,44 @@
+defmodule ElixdoWeb.ListLivePhase7Test do
+  use ElixdoWeb.ConnCase, async: false
+  import Phoenix.LiveViewTest
+  import Mox
+
+  setup :verify_on_exit!
+
+  setup do
+    Mox.stub(Elixdo.Clock.Mock, :today, fn -> ~D[2026-05-01] end)
+    :ok
+  end
+
+  defp secret, do: System.get_env("SECRET_PATH", "dev-secret")
+  defp list_path(date), do: "/#{secret()}/list/#{date}"
+
+  test "voice_input event creates a list item", %{conn: conn} do
+    date = ~D[2026-07-01]
+    {:ok, view, _} = live(conn, list_path("2026-07-01"))
+
+    render_click(view, "voice_input", %{"text" => "buy milk"})
+
+    items = Elixdo.Lists.get_items_for_date(date)
+    assert Enum.any?(items, &(&1.body == "buy milk"))
+  end
+
+  test "voice_input with blank text creates no item", %{conn: conn} do
+    date = ~D[2026-07-02]
+    {:ok, view, _} = live(conn, list_path("2026-07-02"))
+
+    render_click(view, "voice_input", %{"text" => "   "})
+
+    items = Elixdo.Lists.get_items_for_date(date)
+    assert items == []
+  end
+
+  test "voice_input item appears in the rendered list", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-07-03"))
+
+    render_click(view, "voice_input", %{"text" => "call dentist"})
+
+    html = render(view)
+    assert html =~ "call dentist"
+  end
+end
diff --git a/test/elixdo_web/live/list_live_priority_sheet_test.exs b/test/elixdo_web/live/list_live_priority_sheet_test.exs
new file mode 100644
index 0000000..603b3de
--- /dev/null
+++ b/test/elixdo_web/live/list_live_priority_sheet_test.exs
@@ -0,0 +1,53 @@
+defmodule ElixdoWeb.ListLivePrioritySheetTest do
+  use ElixdoWeb.ConnCase, async: false
+  import Phoenix.LiveViewTest
+  import Mox
+
+  setup :verify_on_exit!
+
+  setup do
+    Mox.stub(Elixdo.Clock.Mock, :today, fn -> ~D[2026-09-01] end)
+    :ok
+  end
+
+  defp secret, do: System.get_env("SECRET_PATH", "dev-secret")
+  defp list_path(date), do: "/#{secret()}/list/#{date}"
+
+  test "priority_sheet_open defaults to false at mount", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    refute render(view) =~ "priority-sheet-btn"
+  end
+
+  test "open_priority_sheet sets priority_sheet_open: true", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    view |> element("[phx-click='open_priority_sheet']") |> render_click()
+    assert render(view) =~ "priority-sheet-btn"
+  end
+
+  test "close_priority_sheet sets priority_sheet_open: false", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    view |> element("[phx-click='open_priority_sheet']") |> render_click()
+    view |> element("[phx-click='close_priority_sheet']") |> render_click()
+    refute render(view) =~ "priority-sheet-btn"
+  end
+
+  test "set_priority from the sheet closes the sheet", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    view |> element("[phx-click='open_priority_sheet']") |> render_click()
+    render_click(view, "set_priority", %{"priority" => "⭐"})
+    refute render(view) =~ "priority-sheet-btn"
+  end
+
+  test "set_priority from the sheet applies priority to selected items", %{conn: conn} do
+    date = ~D[2026-09-09]
+    {:ok, [item]} = Elixdo.Lists.create_items(date, [%{body: "important"}])
+
+    {:ok, view, _} = live(conn, list_path("2026-09-09"))
+    view |> element("[phx-click='toggle_select'][phx-value-id='#{item.id}']") |> render_click()
+    view |> element("[phx-click='open_priority_sheet']") |> render_click()
+    render_click(view, "set_priority", %{"priority" => "🔥"})
+
+    updated = Elixdo.Lists.get_items_for_date(date) |> hd()
+    assert updated.priority == "🔥"
+  end
+end
diff --git a/test/elixdo_web/live/list_live_priority_test.exs b/test/elixdo_web/live/list_live_priority_test.exs
new file mode 100644
index 0000000..cfaca1e
--- /dev/null
+++ b/test/elixdo_web/live/list_live_priority_test.exs
@@ -0,0 +1,47 @@
+defmodule ElixdoWeb.ListLivePriorityTest do
+  use ElixdoWeb.ConnCase, async: false
+  import Phoenix.LiveViewTest
+  import Mox
+
+  setup :verify_on_exit!
+
+  setup do
+    Mox.stub(Elixdo.Clock.Mock, :today, fn -> ~D[2026-08-15] end)
+    :ok
+  end
+
+  defp secret, do: System.get_env("SECRET_PATH", "dev-secret")
+  defp list_path(date \\ "2026-08-15"), do: "/#{secret()}/list/#{date}"
+
+  test "default drag handle is ⠿ when priority is nil", %{conn: conn} do
+    {:ok, _} = Elixdo.Lists.create_items(~D[2026-08-15], [%{body: "plain item"}])
+    {:ok, _view, html} = live(conn, list_path())
+    assert html =~ "⠿"
+  end
+
+  test "set_priority sets priority on selected item and renders it in drag handle", %{conn: conn} do
+    date = ~D[2026-08-16]
+    {:ok, [item]} = Elixdo.Lists.create_items(date, [%{body: "prioritize me"}])
+
+    {:ok, view, _} = live(conn, list_path("2026-08-16"))
+    view |> element("[phx-click='toggle_select'][phx-value-id='#{item.id}']") |> render_click()
+    html = view |> element("[phx-click='set_priority'][phx-value-priority='🔥']") |> render_click()
+
+    assert html =~ "🔥"
+    db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
+    assert db_item.priority == "🔥"
+  end
+
+  test "remove_formats clears priority", %{conn: conn} do
+    date = ~D[2026-08-17]
+    {:ok, [item]} = Elixdo.Lists.create_items(date, [%{body: "has priority"}])
+    {:ok, _} = Elixdo.Lists.update_item(item, %{priority: "⭐"})
+
+    {:ok, view, _} = live(conn, list_path("2026-08-17"))
+    view |> element("[phx-click='toggle_select'][phx-value-id='#{item.id}']") |> render_click()
+    view |> element("[phx-click='remove_formats']") |> render_click()
+
+    db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
+    assert db_item.priority == nil
+  end
+end
diff --git a/test/elixdo_web/live/list_live_remove_formats_test.exs b/test/elixdo_web/live/list_live_remove_formats_test.exs
index 1d119f3..7d85eba 100644
--- a/test/elixdo_web/live/list_live_remove_formats_test.exs
+++ b/test/elixdo_web/live/list_live_remove_formats_test.exs
@@ -24,50 +24,6 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     render(view)
   end
 
-  test "remove_formats clears bold on an active item", %{conn: conn} do
-    date = ~D[2026-07-01]
-    {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "bold item"}])
-    item = List.first(items)
-    {:ok, _} = Elixdo.Lists.update_item(item, %{bold: true})
-    refreshed = item |> Map.put(:bold, true)
-
-    {:ok, view, _} = live(conn, list_path("2026-07-01"))
-    select_item(view, refreshed)
-    html = click_remove_formats(view)
-
-    refute html =~ ~r/data-id="#{item.id}"[^>]*bold/
-    db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
-    assert db_item.bold == false
-  end
-
-  test "remove_formats clears italic on an active item", %{conn: conn} do
-    date = ~D[2026-07-02]
-    {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "italic item"}])
-    item = List.first(items)
-    {:ok, _} = Elixdo.Lists.update_item(item, %{italic: true})
-
-    {:ok, view, _} = live(conn, list_path("2026-07-02"))
-    select_item(view, item)
-    click_remove_formats(view)
-
-    db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
-    assert db_item.italic == false
-  end
-
-  test "remove_formats clears highlighted on an active item", %{conn: conn} do
-    date = ~D[2026-07-03]
-    {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "highlighted item"}])
-    item = List.first(items)
-    {:ok, _} = Elixdo.Lists.update_item(item, %{highlighted: true})
-
-    {:ok, view, _} = live(conn, list_path("2026-07-03"))
-    select_item(view, item)
-    click_remove_formats(view)
-
-    db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
-    assert db_item.highlighted == false
-  end
-
   test "remove_formats clears color on an active item", %{conn: conn} do
     date = ~D[2026-07-04]
     {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "colored item"}])
@@ -90,7 +46,7 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "completed formatted"}])
     item = List.first(items)
     {:ok, completed} = Elixdo.Lists.update_item(item, %{status: :completed})
-    {:ok, _} = Elixdo.Lists.update_item(completed, %{bold: true, color: :blue})
+    {:ok, _} = Elixdo.Lists.update_item(completed, %{color: :blue})
 
     {:ok, view, _} = live(conn, list_path("2026-07-05"))
     select_item(view, item)
@@ -99,7 +55,6 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     assert html =~ ~s(class="item active")
     db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
     assert db_item.status == :active
-    assert db_item.bold == false
     assert db_item.color == nil
   end
 
@@ -109,8 +64,7 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     date = ~D[2026-07-06]
     {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "wiggled formatted"}])
     item = List.first(items)
-    {:ok, wiggled} = Elixdo.Lists.update_item(item, %{status: :wiggled_out})
-    {:ok, _} = Elixdo.Lists.update_item(wiggled, %{italic: true})
+    {:ok, _wiggled} = Elixdo.Lists.update_item(item, %{status: :wiggled_out})
 
     {:ok, view, _} = live(conn, list_path("2026-07-06"))
     select_item(view, item)
@@ -119,7 +73,6 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     assert html =~ ~s(class="item active")
     db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
     assert db_item.status == :active
-    assert db_item.italic == false
   end
 
   test "remove_formats on an arrowed_out item restores it to active and clears arrow", %{
@@ -129,7 +82,7 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     target_date = ~D[2026-07-08]
 
     {:ok, items} =
-      Elixdo.Lists.create_items(date, [%{body: "arrowed formatted", bold: true, color: :green}])
+      Elixdo.Lists.create_items(date, [%{body: "arrowed formatted", color: :green}])
 
     item = List.first(items)
     {:ok, _original, _copy} = Elixdo.Lists.arrow_item(item, target_date)
@@ -147,11 +100,12 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
     assert db_item.status == :active
     assert db_item.arrowed_to_date == nil
-    assert db_item.bold == false
     assert db_item.color == nil
 
     # Copy on the target date must be untouched
-    copy = Elixdo.Lists.get_items_for_date(target_date) |> Enum.find(&(&1.body == "arrowed formatted"))
+    copy =
+      Elixdo.Lists.get_items_for_date(target_date) |> Enum.find(&(&1.body == "arrowed formatted"))
+
     assert copy != nil
     assert copy.status == :active
   end
@@ -161,22 +115,13 @@ defmodule ElixdoWeb.ListLiveRemoveFormatsTest do
     {:ok, items} = Elixdo.Lists.create_items(date, [%{body: "all formats"}])
     item = List.first(items)
 
-    {:ok, _} =
-      Elixdo.Lists.update_item(item, %{
-        bold: true,
-        italic: true,
-        highlighted: true,
-        color: :purple
-      })
+    {:ok, _} = Elixdo.Lists.update_item(item, %{color: :purple})
 
     {:ok, view, _} = live(conn, list_path("2026-07-09"))
     select_item(view, item)
     click_remove_formats(view)
 
     db_item = Elixdo.Lists.get_items_for_date(date) |> Enum.find(&(&1.id == item.id))
-    assert db_item.bold == false
-    assert db_item.italic == false
-    assert db_item.highlighted == false
     assert db_item.color == nil
     assert db_item.status == :active
   end
diff --git a/test/elixdo_web/live/list_live_sort_test.exs b/test/elixdo_web/live/list_live_sort_test.exs
new file mode 100644
index 0000000..c8a7652
--- /dev/null
+++ b/test/elixdo_web/live/list_live_sort_test.exs
@@ -0,0 +1,165 @@
+defmodule ElixdoWeb.ListLiveSortTest do
+  use ElixdoWeb.ConnCase, async: false
+  import Phoenix.LiveViewTest
+  import Mox
+
+  setup :verify_on_exit!
+
+  setup do
+    Mox.stub(Elixdo.Clock.Mock, :today, fn -> ~D[2026-09-01] end)
+    :ok
+  end
+
+  defp secret, do: System.get_env("SECRET_PATH", "dev-secret")
+  defp list_path(date), do: "/#{secret()}/list/#{date}"
+
+  defp item_bodies_from_html(html) do
+    ~r/class="item-text">([^<]+)<\/span>/
+    |> Regex.scan(html, capture: :all_but_first)
+    |> List.flatten()
+  end
+
+  defp db_bodies(date) do
+    date
+    |> Elixdo.Lists.get_items_for_date()
+    |> Enum.map(& &1.body)
+  end
+
+  defp sort_and_render(view) do
+    view |> element("[phx-click='sort_active']") |> render_click()
+    render(view)
+  end
+
+  test "sort_active moves active items before completed", %{conn: conn} do
+    date = ~D[2026-09-02]
+
+    {:ok, [a, b, c]} =
+      Elixdo.Lists.create_items(date, [
+        %{body: "active one"},
+        %{body: "done"},
+        %{body: "active two"}
+      ])
+
+    {:ok, _} = Elixdo.Lists.update_item(b, %{status: :completed})
+
+    {:ok, view, _} = live(conn, list_path("2026-09-02"))
+    html = sort_and_render(view)
+
+    bodies = item_bodies_from_html(html)
+    active_pos = Enum.find_index(bodies, &(&1 == "active one"))
+    active2_pos = Enum.find_index(bodies, &(&1 == "active two"))
+    done_pos = Enum.find_index(bodies, &(&1 == "done"))
+
+    assert active_pos < done_pos
+    assert active2_pos < done_pos
+    _ = {a, c}
+  end
+
+  test "sort_active preserves within-group order", %{conn: conn} do
+    date = ~D[2026-09-03]
+
+    {:ok, [a, b, c, d]} =
+      Elixdo.Lists.create_items(date, [
+        %{body: "active first"},
+        %{body: "completed first"},
+        %{body: "active second"},
+        %{body: "completed second"}
+      ])
+
+    {:ok, _} = Elixdo.Lists.update_item(b, %{status: :completed})
+    {:ok, _} = Elixdo.Lists.update_item(d, %{status: :completed})
+
+    {:ok, view, _} = live(conn, list_path("2026-09-03"))
+    html = sort_and_render(view)
+
+    bodies = item_bodies_from_html(html)
+
+    assert Enum.find_index(bodies, &(&1 == "active first")) <
+             Enum.find_index(bodies, &(&1 == "active second"))
+
+    assert Enum.find_index(bodies, &(&1 == "completed first")) <
+             Enum.find_index(bodies, &(&1 == "completed second"))
+
+    _ = {a, c}
+  end
+
+  test "sort_active on already-sorted list is a no-op", %{conn: conn} do
+    date = ~D[2026-09-04]
+
+    {:ok, [a, b, c]} =
+      Elixdo.Lists.create_items(date, [
+        %{body: "alpha"},
+        %{body: "beta"},
+        %{body: "done"}
+      ])
+
+    {:ok, _} = Elixdo.Lists.update_item(c, %{status: :completed})
+
+    {:ok, view, _} = live(conn, list_path("2026-09-04"))
+    html = sort_and_render(view)
+
+    assert item_bodies_from_html(html) == ["alpha", "beta", "done"]
+    _ = {a, b}
+  end
+
+  test "sort_active on all-active list preserves order", %{conn: conn} do
+    date = ~D[2026-09-05]
+
+    {:ok, _} =
+      Elixdo.Lists.create_items(date, [
+        %{body: "first"},
+        %{body: "second"},
+        %{body: "third"}
+      ])
+
+    {:ok, view, _} = live(conn, list_path("2026-09-05"))
+    html = sort_and_render(view)
+
+    assert item_bodies_from_html(html) == ["first", "second", "third"]
+  end
+
+  test "sort_active on all-non-active list preserves order", %{conn: conn} do
+    date = ~D[2026-09-06]
+
+    {:ok, [a, b, c]} =
+      Elixdo.Lists.create_items(date, [
+        %{body: "done one"},
+        %{body: "done two"},
+        %{body: "done three"}
+      ])
+
+    {:ok, _} = Elixdo.Lists.update_item(a, %{status: :completed})
+    {:ok, _} = Elixdo.Lists.update_item(b, %{status: :completed})
+    {:ok, _} = Elixdo.Lists.update_item(c, %{status: :completed})
+
+    {:ok, view, _} = live(conn, list_path("2026-09-06"))
+    html = sort_and_render(view)
+
+    assert item_bodies_from_html(html) == ["done one", "done two", "done three"]
+  end
+
+  test "sort_active persists to DB", %{conn: conn} do
+    date = ~D[2026-09-07]
+
+    {:ok, [a, b, c]} =
+      Elixdo.Lists.create_items(date, [
+        %{body: "active"},
+        %{body: "completed"},
+        %{body: "active two"}
+      ])
+
+    {:ok, _} = Elixdo.Lists.update_item(b, %{status: :completed})
+
+    {:ok, view, _} = live(conn, list_path("2026-09-07"))
+    sort_and_render(view)
+
+    assert db_bodies(date) == ["active", "active two", "completed"]
+    _ = {a, c}
+  end
+
+  test "sort_active on empty list is a no-op", %{conn: conn} do
+    {:ok, view, _} = live(conn, list_path("2026-09-01"))
+    html = sort_and_render(view)
+    assert item_bodies_from_html(html) == []
+  end
+end
diff --git a/test/elixdo_web/live/list_live_test.exs b/test/elixdo_web/live/list_live_test.exs
index 7da0254..f51e765 100644
--- a/test/elixdo_web/live/list_live_test.exs
+++ b/test/elixdo_web/live/list_live_test.exs
@@ -14,37 +14,37 @@ defmodule ElixdoWeb.ListLiveTest do
 
   test "mounts and shows today's date", %{conn: conn} do
     {:ok, _view, html} = live(conn, "/#{secret()}/list")
-    assert html =~ "May 1, 2026"
+    assert html =~ "May 1"
   end
 
   test "navigating prev_day changes date", %{conn: conn} do
     {:ok, view, _html} = live(conn, "/#{secret()}/list")
     html = view |> element("button.nav-left") |> render_click()
-    assert html =~ "April 30, 2026"
+    assert html =~ "April 30"
   end
 
   test "navigating next_day changes date", %{conn: conn} do
     {:ok, view, _html} = live(conn, "/#{secret()}/list")
     html = view |> element("button.nav-right") |> render_click()
-    assert html =~ "May 2, 2026"
+    assert html =~ "May 2"
   end
 
   test "arrow key left navigates to prev day", %{conn: conn} do
     {:ok, view, _html} = live(conn, "/#{secret()}/list")
     html = render_keydown(view, "key_nav", %{"key" => "ArrowLeft"})
-    assert html =~ "April 30, 2026"
+    assert html =~ "April 30"
   end
 
   test "arrow key right navigates to next day", %{conn: conn} do
     {:ok, view, _html} = live(conn, "/#{secret()}/list")
     html = render_keydown(view, "key_nav", %{"key" => "ArrowRight"})
-    assert html =~ "May 2, 2026"
+    assert html =~ "May 2"
   end
 
   test "date picker jump navigates to selected date", %{conn: conn} do
     {:ok, view, _html} = live(conn, "/#{secret()}/list")
     html = view |> element("#date-picker-form") |> render_change(%{"date" => "2026-06-15"})
-    assert html =~ "June 15, 2026"
+    assert html =~ "June 15"
   end
 
   test "return to today button hidden when on today", %{conn: conn} do
@@ -60,7 +60,7 @@ defmodule ElixdoWeb.ListLiveTest do
   test "return to today button navigates home", %{conn: conn} do
     {:ok, view, _} = live(conn, "/#{secret()}/list/2026-04-01")
     html = view |> element("button.today-btn") |> render_click()
-    assert html =~ "May 1, 2026"
+    assert html =~ "May 1"
   end
 
   test "DateWatcher midnight broadcast updates today assign", %{conn: conn} do
@@ -196,7 +196,7 @@ defmodule ElixdoWeb.ListLiveTest do
       html =
         view |> element(".search-result-item", "unique searchable item xyz") |> render_click()
 
-      assert html =~ "June 20, 2026"
+      assert html =~ "June 20"
 
       # The highlighted item should have the search-highlight class
       assert html =~ "search-highlight"