diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
new file mode 100644
index 00000000..4ca068aa
--- /dev/null
+++ b/.claude-plugin/marketplace.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-marketplace.json",
+  "name": "allthings",
+  "description": "allthings evenings in San Francisco, for people who build software, in Claude Code.",
+  "owner": {
+    "name": "allthings",
+    "url": "https://allthings.dev"
+  },
+  "plugins": [
+    {
+      "name": "allthings",
+      "source": "./plugins/allthings",
+      "description": "The next allthings evening above your prompt, /at and /imin, tool rows in the slash grammar, the allthings themes and voice, and the allthings MCP server.",
+      "category": "community"
+    }
+  ]
+}
diff --git a/.github/scripts/claude-code.sh b/.github/scripts/claude-code.sh
new file mode 100755
index 00000000..383e872e
--- /dev/null
+++ b/.github/scripts/claude-code.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Installs Claude Code at the version CLAUDE_CODE_VERSION pins, puts it on the
+# job's PATH, and lays the types Claude Code writes beside the allthings mod
+# (plugins/allthings/.claude-plugin/types/, gitignored) so its tsconfig and
+# the type-aware lint resolve `claude-code`. Laying them loads the plugin
+# headless under a throwaway HOME: no sign-in, no model call, no turn.
+set -euo pipefail
+
+: "${CLAUDE_CODE_VERSION:?set CLAUDE_CODE_VERSION}"
+temp="${RUNNER_TEMP:-$(mktemp -d)}"
+prefix="$temp/claude-code"
+mkdir -p "$prefix"
+(
+  cd "$prefix"
+  bun add --exact "@anthropic-ai/claude-code@${CLAUDE_CODE_VERSION}" >/dev/null
+)
+bin="$prefix/node_modules/.bin"
+if [[ -n "${GITHUB_PATH:-}" ]]; then
+  echo "$bin" >>"$GITHUB_PATH"
+fi
+"$bin/claude" --version
+
+plugin="${GITHUB_WORKSPACE:-$(pwd)}/plugins/allthings"
+home="$temp/claude-home"
+mkdir -p "$home"
+# An unknown command is enough: the plugin loads, its types are laid, and the
+# run ends without a turn.
+HOME="$home" "$bin/claude" -p "/allthings-lay-types" --plugin-dir "$plugin" </dev/null >/dev/null 2>&1 || true
+rm -rf "$home"
+test -f "$plugin/.claude-plugin/types/claude-code/index.d.ts" || {
+  echo "::error::Claude Code did not lay the allthings mod's types"
+  exit 1
+}
+head -n 1 "$plugin/.claude-plugin/types/claude-code/index.d.ts"
diff --git a/.github/workflows/brand.yaml b/.github/workflows/brand.yaml
index 69995c7b..9506e6af 100644
--- a/.github/workflows/brand.yaml
+++ b/.github/workflows/brand.yaml
@@ -6,6 +6,9 @@ on:
     paths:
       - "brand/**"
       - "app/public/brand/**"
+      # The Claude Code plugin's themes and palette, held to the tokens.
+      - "plugins/allthings/themes/**"
+      - "plugins/allthings/hooks/palette.ts"
       - "package.json"
       - "bun.lock"
       - ".github/workflows/brand.yaml"
@@ -14,6 +17,8 @@ on:
     paths:
       - "brand/**"
       - "app/public/brand/**"
+      - "plugins/allthings/themes/**"
+      - "plugins/allthings/hooks/palette.ts"
       - "package.json"
       - "bun.lock"
       - ".github/workflows/brand.yaml"
diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml
index 3dc7c670..805e2c87 100644
--- a/.github/workflows/lint.yaml
+++ b/.github/workflows/lint.yaml
@@ -50,6 +50,13 @@ jobs:
         working-directory: tools/pr-header
         run: bash "$GITHUB_WORKSPACE/.github/scripts/bun-install.sh"
 
+      # The allthings mod (plugins/allthings) types against the declarations
+      # Claude Code lays beside it; its tsconfig extends them.
+      - name: 🤖 Lay the Claude Code mod's types
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/claude-code.sh"
+        env:
+          CLAUDE_CODE_VERSION: "2.1.293"
+
       # web/src imports the manifest its build writes to web/dist.
       - name: 🏗️ Build web
         working-directory: web
diff --git a/.github/workflows/plugin.yaml b/.github/workflows/plugin.yaml
new file mode 100644
index 00000000..af351bd7
--- /dev/null
+++ b/.github/workflows/plugin.yaml
@@ -0,0 +1,61 @@
+name: Claude plugin
+
+# The allthings plugin for Claude Code (plugins/allthings): its manifests
+# validate, its mod type-checks against the types Claude Code writes, and the
+# mod's tests pass under Claude Code's own test kit, with no session, sign-in
+# or network.
+on:
+  push:
+    branches: ["main"]
+    paths:
+      - "plugins/**"
+      - ".claude-plugin/**"
+      - ".github/workflows/plugin.yaml"
+      - ".github/scripts/claude-code.sh"
+  pull_request:
+    paths:
+      - "plugins/**"
+      - ".claude-plugin/**"
+      - ".github/workflows/plugin.yaml"
+      - ".github/scripts/claude-code.sh"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: plugin-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  # Mods need 2.1.287 or later; bump this with the version the README names.
+  CLAUDE_CODE_VERSION: "2.1.293"
+  TYPESCRIPT_VERSION: "5.9.3"
+
+jobs:
+  mod:
+    name: 🧩 The mod validates, type-checks and passes its tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+        with:
+          persist-credentials: false
+
+      - name: 🍞 Setup Bun
+        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with:
+          bun-version: 1.3.14
+
+      - name: 🤖 Install Claude Code and lay the mod's types
+        run: bash "$GITHUB_WORKSPACE/.github/scripts/claude-code.sh"
+
+      - name: ✅ Validate the marketplace and the plugin
+        run: |
+          claude plugin validate --strict .
+          claude plugin validate --strict plugins/allthings
+
+      - name: 🔍 Type check the mod
+        run: bunx --package "typescript@${TYPESCRIPT_VERSION}" tsc -p plugins/allthings
+
+      - name: 🏄 Run the mod's tests
+        run: claude plugin test plugins/allthings
diff --git a/.gitignore b/.gitignore
index ba2c1472..fa2ad778 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,3 +30,6 @@ playwright-report/
 
 # Alchemy local state, wherever a test or a deploy runs from
 .alchemy/
+
+# The types Claude Code lays beside a mod each time it loads it
+plugins/*/.claude-plugin/types/
diff --git a/brand/tests/claude-plugin.test.ts b/brand/tests/claude-plugin.test.ts
new file mode 100644
index 00000000..25398326
--- /dev/null
+++ b/brand/tests/claude-plugin.test.ts
@@ -0,0 +1,76 @@
+import { describe, expect, test } from "bun:test";
+import { join } from "node:path";
+import { colors, tokens } from "../src/tokens.ts";
+
+// The Claude Code plugin (plugins/allthings) draws with the brand's colors:
+// its themes and its mod's palette are held to the tokens here, so a token
+// that changes moves them too.
+
+const plugin = join(import.meta.dir, "../../plugins/allthings");
+
+const hex = Object.fromEntries(
+  colors(tokens).map((color) => [color.name, color.hex.toUpperCase()]),
+);
+
+type Theme = {
+  name: string;
+  base: string;
+  overrides: Record<string, string>;
+};
+
+async function theme(slug: string): Promise<Theme> {
+  return (await Bun.file(
+    join(plugin, "themes", `${slug}.json`),
+  ).json()) as Theme;
+}
+
+describe("the Claude Code plugin's colors", () => {
+  test("allthings night is Night's palette: Glow for the accent, Lavender for meta", async () => {
+    const night = await theme("allthings-night");
+    expect(night.name).toBe("allthings night");
+    expect(night.base).toBe("dark");
+    expect(night.overrides).toMatchObject({
+      claude: hex["glow"],
+      text: hex["paper"],
+      inactive: hex["lavender"],
+      suggestion: hex["lavender"],
+      promptBorder: hex["ruleNight"],
+      userMessageBackground: hex["nightRaised"],
+      selectionBg: hex["ruleNight"],
+    });
+  });
+
+  test("allthings paper is Paper's palette: Ink text, Bridge for the accent", async () => {
+    const paper = await theme("allthings-paper");
+    expect(paper.name).toBe("allthings paper");
+    expect(paper.base).toBe("light");
+    expect(paper.overrides).toMatchObject({
+      claude: hex["bridge"],
+      text: hex["ink"],
+      inactive: hex["karlText"],
+      suggestion: hex["violet"],
+      promptBorder: hex["rulePaper"],
+      userMessageBackground: hex["karl"],
+      selectionBg: hex["rulePaper"],
+    });
+  });
+
+  test("the mod's palette is the tokens' own", async () => {
+    const source = await Bun.file(join(plugin, "hooks/palette.ts")).text();
+    const palette = Object.fromEntries(
+      [...source.matchAll(/export const (\w+) = "(#[0-9A-F]{6})";/g)].map(
+        ([, name, value]) => [name, value],
+      ),
+    );
+    expect(palette).toEqual({
+      NIGHT: hex["night"],
+      PAPER: hex["paper"],
+      INK: hex["ink"],
+      BRIDGE: hex["bridge"],
+      GLOW: hex["glow"],
+      LAVENDER: hex["lavender"],
+      DUSK: hex["dusk"],
+      VIOLET: hex["violet"],
+    });
+  });
+});
diff --git a/plugins/allthings/.claude-plugin/plugin.json b/plugins/allthings/.claude-plugin/plugin.json
new file mode 100644
index 00000000..770bf968
--- /dev/null
+++ b/plugins/allthings/.claude-plugin/plugin.json
@@ -0,0 +1,22 @@
+{
+  "name": "allthings",
+  "version": "0.3.0",
+  "description": "allthings evenings in San Francisco, for people who build software: the next evening above your prompt, /at and /imin, tool rows in the slash grammar, and the allthings themes and voice.",
+  "author": {
+    "name": "allthings",
+    "url": "https://allthings.dev"
+  },
+  "homepage": "https://allthings.dev",
+  "repository": "https://github.com/allthingsweb-dev/allthingsweb",
+  "keywords": [
+    "evenings",
+    "meetups",
+    "hackathons",
+    "san francisco",
+    "software",
+    "community",
+    "mod"
+  ],
+  "mcpServers": "./mcp.json",
+  "types": "./types/index.d.ts"
+}
diff --git a/plugins/allthings/README.md b/plugins/allthings/README.md
new file mode 100644
index 00000000..b9942ea8
--- /dev/null
+++ b/plugins/allthings/README.md
@@ -0,0 +1,69 @@
+# allthings for agents
+
+Evenings for people who build software, in the neighborhoods of San Francisco, inside your coding agent.
+
+The plugin gives an agent the allthings MCP server (`list_events`, `get_event`, `list_speakers`, `get_community`) and two skills, `find-evenings` and `evening-briefing`. In Claude Code it also brings a mod that takes over the interface with the allthings/\_ look, two themes and an output style.
+
+| File                         | For                                                                                                   |
+| ---------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `plugin.json`, `mcp.json`    | The [Agent Plugins](https://agent-plugins.org) manifest and MCP config, read by every host            |
+| `.claude-plugin/plugin.json` | Claude Code's manifest: the same plugin, its MCP server from `mcp.json`, and the mod's state contract |
+| `skills/`                    | The two skills                                                                                        |
+| `hooks/`, `types/`, `tests/` | The Claude Code mod and its tests                                                                     |
+| `themes/`, `output-styles/`  | The allthings night and allthings paper themes, and the allthings output style                        |
+
+## Try it in Claude Code
+
+Mods need Claude Code 2.1.287 or later in the terminal (`claude --version`), or 2.1.286 in the Desktop app (`/status`). This plugin is tested with 2.1.293.
+
+For one session, from a clone of this repository:
+
+```bash
+claude --plugin-dir plugins/allthings
+```
+
+To keep it, add this repository as a marketplace and install the plugin:
+
+```bash
+claude plugin marketplace add allthingsweb-dev/allthingsweb
+claude plugin install allthings@allthings
+```
+
+or, at the Claude Code prompt, `/plugin marketplace add allthingsweb-dev/allthingsweb` and then `/plugin install allthings@allthings`. Run `/plugin` to see `allthings` among the active mods.
+
+## What the mod does
+
+- **Tool rows in the slash grammar.** Each tool call's row reads as a verb, a slash and what it acts on: `read/src/app.ts`, `edit/home.tsx`, `bash/bun test`, `search/"curation"`, `fetch/allthings.dev`, `agent/Find the venue table`, and `allthings/list_events` for an MCP tool. The slash is Bridge on light themes and Glow on dark ones. The status dot, the error color, `Interrupted` and the result under the row are Claude Code's own; whatever else Claude Code's row shows (a line range, a glob, an agent type) follows in dim. Rows inside an expanded group, which carry their output, and the Desktop app's rows, which expand and collapse themselves, stay as Claude Code draws them.
+- **The spinner wanders the city.** While Claude works the spinner reads `allthings/_ shipping in SoMa…`, the cursor blinking, then `pairing in the Mission…`, `debugging in Dogpatch…`, `refactoring in the Tenderloin…`, `deploying from FiDi…`, through 36 real neighborhoods. Claude Code's elapsed time and tokens stay after it.
+- **The next evening, above the prompt.** A slim Night band: the date, `allthings/<topic>_`, the neighborhood, the host, and an **I'm in →** button that opens the evening's Luma page. On the day it counts down (`tonight · in 2h 14m`); during the evening it says `live now`; once you've pressed the button it says `see you at/<topic>`. No evening ahead, or no network, and there is no band.
+- **`/at`** prints the next evening's card: when, where, who's on stage, and where to say you're in. **`/at <slug>`** prints any evening's. **`/imin`** opens the next evening's Luma page. All three answer at once, with no Claude turn, even while Claude is working.
+
+With `reduceMotion` on in `/config`, the cursors stay solid.
+
+### Where the data comes from
+
+The band and the commands call `list_events` (upcoming, limit 1) and `get_event` on the MCP server this plugin configures in `mcp.json`, (allthings.dev/mcp), so a change of URL there, such as a local server while developing, moves them too. The next evening is cached in the plugin's store and asked for again about every 30 minutes, or when it ends. When the site can't be reached the mod stays quiet: a cached evening shows for up to two hours, then the band goes. A headless run (`claude -p`, the SDK) asks the site only when a command does.
+
+`claude plugin validate plugins/allthings` lists everything the mod reaches: the network (`$.http.fetch`, to the MCP URL alone), the plugin's own files (`$.fs.read`, for `mcp.json`), its store, `/config`'s theme and reduce-motion rows, the `COLORFGBG` variable, and `$.process.run` for `open`, `xdg-open` or `start` when you press **I'm in**.
+
+## Themes and the output style
+
+`/theme` lists **allthings night** and **allthings paper**. Claude Code colors its own interface and leaves the terminal's background alone, so set the terminal's background to Night (`#1B1729`) or Paper (`#F4F1EC`) to match. The themes take their colors from the brand tokens (`brand/all-things.tokens.json`), and a test in `brand/` holds them there.
+
+The **allthings** output style keeps Claude Code's coding instructions and changes only the voice: plain and warm, lowercase where natural, neighborhoods by name, evenings rather than events, "I'm in" and never RSVP. It is opt-in: pick it with `/output-style allthings:allthings`, or under **Output style** in `/config`.
+
+## Developing the mod
+
+Claude Code writes the mod's type declarations into `.claude-plugin/types/` (gitignored) each time it loads the plugin from a folder, as with `--plugin-dir`. Then, from the repository root:
+
+```bash
+claude plugin validate --strict plugins/allthings
+bunx --package typescript@5.9.3 tsc -p plugins/allthings
+claude plugin test plugins/allthings
+```
+
+The tests run on Claude Code's own test kit, with no session, sign-in or network: every answer from the site is a fixture in `tests/fixtures.ts`. CI (`.github/workflows/plugin.yaml`) runs the three on every change to the plugin.
+
+## Next
+
+Hack mode, `/hack start` and `/hack submit` for hackathon evenings, is planned for v2 and isn't built yet.
diff --git a/plugins/allthings/hooks/city.ts b/plugins/allthings/hooks/city.ts
new file mode 100644
index 00000000..dad97fc6
--- /dev/null
+++ b/plugins/allthings/hooks/city.ts
@@ -0,0 +1,173 @@
+/**
+ * San Francisco, as the mod names it: the neighborhoods the spinner wanders
+ * through, and the one an evening's venue stands in.
+ *
+ * Only real neighborhoods, by the names locals use (brand/foundations.md,
+ * "Places"): FiDi, not the Financial District.
+ */
+
+/** A neighborhood and how a sentence names it ("in the Mission"). */
+type Hood = { name: string; inSentence: string };
+
+const hood = (name: string, article = ""): Hood => ({
+  name,
+  inSentence: article ? `${article} ${name}` : name,
+});
+
+/** The spinner's walk through the city, in order. */
+export const NEIGHBORHOODS: readonly Hood[] = [
+  hood("SoMa"),
+  hood("Mission", "the"),
+  hood("Dogpatch"),
+  hood("Tenderloin", "the"),
+  hood("FiDi"),
+  hood("East Cut"),
+  hood("Potrero Hill"),
+  hood("Mission Bay"),
+  hood("Hayes Valley"),
+  hood("North Beach"),
+  hood("Chinatown"),
+  hood("Nob Hill"),
+  hood("Russian Hill"),
+  hood("Union Square"),
+  hood("Mid-Market"),
+  hood("Japantown"),
+  hood("Castro", "the"),
+  hood("Noe Valley"),
+  hood("Bernal Heights"),
+  hood("Glen Park"),
+  hood("Haight", "the"),
+  hood("Cole Valley"),
+  hood("NoPa"),
+  hood("Richmond", "the"),
+  hood("Sunset", "the"),
+  hood("Marina", "the"),
+  hood("Cow Hollow"),
+  hood("Pacific Heights"),
+  hood("Jackson Square"),
+  hood("Telegraph Hill"),
+  hood("Excelsior", "the"),
+  hood("Bayview"),
+  hood("Presidio", "the"),
+  hood("Duboce Triangle"),
+  hood("Lower Haight"),
+  hood("Western Addition", "the"),
+];
+
+/** What the spinner says someone is doing there, and the preposition it takes. */
+const WORK: readonly (readonly [verb: string, preposition: string])[] = [
+  ["shipping", "in"],
+  ["pairing", "in"],
+  ["debugging", "in"],
+  ["refactoring", "in"],
+  ["deploying", "from"],
+  ["reviewing", "in"],
+  ["testing", "in"],
+  ["profiling", "in"],
+  ["rebasing", "in"],
+  ["prototyping", "in"],
+  ["bisecting", "in"],
+  ["typechecking", "in"],
+  ["benchmarking", "in"],
+  ["merging", "in"],
+  ["migrating", "in"],
+  ["hacking", "in"],
+  ["sketching", "in"],
+  ["pushing", "from"],
+  ["linting", "in"],
+  ["demoing", "in"],
+];
+
+/**
+ * The spinner's nth line, such as "shipping in SoMa": the verbs and the
+ * neighborhoods each cycle on their own, so the pairs keep changing.
+ */
+export function phraseAt(n: number): string {
+  const index = Math.max(0, Math.floor(n));
+  const [verb, preposition] = WORK[index % WORK.length] ?? ["shipping", "in"];
+  const place = NEIGHBORHOODS[index % NEIGHBORHOODS.length] ?? NEIGHBORHOODS[0];
+  return `${verb} ${preposition} ${place?.inSentence ?? "SoMa"}`;
+}
+
+/** Venues the community has met at, by street address (brand/foundations.md). */
+const VENUES: readonly (readonly [address: string, neighborhood: string])[] = [
+  ["201 spear st", "East Cut"],
+  ["100 1st st", "East Cut"],
+  ["45 fremont st", "FiDi"],
+  ["351 california st", "FiDi"],
+  ["50 beale st", "FiDi"],
+  ["525 market st", "FiDi"],
+  ["585 market st", "FiDi"],
+  ["660 market st", "FiDi"],
+  ["1 post st", "FiDi"],
+  ["40 o'farrell st", "Union Square"],
+  ["760 market st", "Union Square"],
+  ["444 de haro st", "Potrero Hill"],
+  ["277 carolina st", "Potrero Hill"],
+  ["pier 70", "Dogpatch"],
+  ["1242 market st", "Mid-Market"],
+  ["360 ritch st", "SoMa"],
+  ["620 treat ave", "Mission"],
+  ["500 terry a francois blvd", "Mission Bay"],
+];
+
+/** Otherwise the neighborhood a ZIP code mostly covers, by its local name. */
+const ZIPS: Readonly<Record<string, string>> = {
+  "94102": "Mid-Market",
+  "94103": "SoMa",
+  "94104": "FiDi",
+  "94105": "East Cut",
+  "94107": "SoMa",
+  "94108": "Union Square",
+  "94109": "Nob Hill",
+  "94110": "Mission",
+  "94111": "FiDi",
+  "94112": "Excelsior",
+  "94114": "Castro",
+  "94115": "Western Addition",
+  "94116": "Parkside",
+  "94117": "Haight",
+  "94118": "Inner Richmond",
+  "94121": "Outer Richmond",
+  "94122": "Inner Sunset",
+  "94123": "Marina",
+  "94124": "Bayview",
+  "94127": "West Portal",
+  "94129": "Presidio",
+  "94130": "Treasure Island",
+  "94131": "Noe Valley",
+  "94132": "Lakeshore",
+  "94133": "North Beach",
+  "94134": "Visitacion Valley",
+  "94158": "Mission Bay",
+};
+
+/**
+ * The neighborhood of a venue's address: a venue the community knows by its
+ * street address, else the ZIP code's, else null (left out, never guessed).
+ */
+export function neighborhoodOf(address: string | null): string | null {
+  if (address === null) return null;
+  const plain = address
+    .toLowerCase()
+    .replaceAll("’", "'")
+    .replaceAll(/\bstreet\b/g, "st")
+    .replaceAll(/\s+/g, " ");
+  // Words, so "45 fremont st" is found in "sentry, 45 fremont st, ..." and
+  // never inside "145 fremont st".
+  const words = ` ${plain.replaceAll(/[^a-z0-9']+/g, " ").trim()} `;
+  for (const [street, neighborhood] of VENUES) {
+    if (words.includes(` ${street} `)) return neighborhood;
+  }
+  if (!/san francisco|\bsf\b/.test(plain)) return null;
+  const zip = /\b(94\d{3})\b/.exec(plain)?.[1];
+  return zip === undefined ? null : (ZIPS[zip] ?? null);
+}
+
+/** Where a turn's walk starts: a number from its id, so each turn sets out somewhere else. */
+export function seedOf(turnId: string): number {
+  let hash = 0;
+  for (const char of turnId)
+    hash = (hash * 31 + (char.codePointAt(0) ?? 0)) % 9_973;
+  return hash;
+}
diff --git a/plugins/allthings/hooks/evenings.ts b/plugins/allthings/hooks/evenings.ts
new file mode 100644
index 00000000..169fc6af
--- /dev/null
+++ b/plugins/allthings/hooks/evenings.ts
@@ -0,0 +1,322 @@
+/**
+ * Evenings from the site's MCP server: where the server is, how to ask it,
+ * what its answers mean, and what the band and `/at` say about them.
+ *
+ * Everything here is plain functions of their arguments; register.tsx makes
+ * the calls through `$`.
+ */
+
+import type { Evening, EveningTalk } from "../types";
+import { neighborhoodOf } from "./city";
+import {
+  clockOf,
+  dayOf,
+  isEveningStart,
+  isSameDay,
+  spanOf,
+  untilOf,
+} from "./time";
+
+/** How long a fetched next evening counts as fresh: refresh about every 30 minutes. */
+export const FRESH_MS = 30 * 60_000;
+
+/** How long a cached evening outlives a failed refresh before the band goes quiet. */
+export const GRACE_MS = 2 * 60 * 60_000;
+
+/** The wordmark, always one word, the cursor after the slash. */
+export const WORDMARK = "allthings";
+
+/**
+ * The MCP server's URL from a plugin MCP config (`mcpServers`, or servers at
+ * the top level): the `allthings` server's, else the first with an http(s)
+ * URL. Null when the file names none.
+ */
+export function endpointOf(configText: string): string | null {
+  let config: unknown;
+  try {
+    config = JSON.parse(configText);
+  } catch {
+    return null;
+  }
+  if (!isRecord(config)) return null;
+  const servers = isRecord(config.mcpServers) ? config.mcpServers : config;
+  const named = servers.allthings;
+  const candidates = [named, ...Object.values(servers)];
+  for (const server of candidates) {
+    if (isRecord(server) && typeof server.url === "string") {
+      const url = parseUrl(server.url);
+      if (
+        url !== null &&
+        (url.protocol === "https:" || url.protocol === "http:")
+      ) {
+        return url.href;
+      }
+    }
+  }
+  return null;
+}
+
+/** The body of a JSON-RPC `tools/call` request for one tool. */
+export function toolCallBody(
+  name: string,
+  args: Record<string, unknown>,
+): string {
+  return JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name, arguments: args },
+  });
+}
+
+/** The headers a stateless streamable-HTTP MCP server takes a call with. */
+export const TOOL_CALL_HEADERS: Readonly<Record<string, string>> = {
+  "content-type": "application/json",
+  accept: "application/json, text/event-stream",
+  "mcp-protocol-version": "2025-06-18",
+};
+
+/** A tool's answer: its structured content, or the text of its error. */
+export type ToolAnswer =
+  | { isError: false; structured: unknown }
+  | { isError: true; message: string };
+
+/**
+ * Reads one JSON-RPC answer from a JSON or event-stream body. Throws when the
+ * body is neither, or the server answered with an RPC error.
+ */
+export function toolAnswerOf(body: string, contentType: string): ToolAnswer {
+  const json = contentType.includes("text/event-stream")
+    ? body
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trim())
+        .join("")
+    : body;
+  const rpc: unknown = JSON.parse(json);
+  if (!isRecord(rpc)) throw new Error("not a JSON-RPC answer");
+  if (isRecord(rpc.error)) {
+    const message = rpc.error.message;
+    throw new Error(
+      typeof message === "string" ? message : "the server refused the call",
+    );
+  }
+  const result = rpc.result;
+  if (!isRecord(result)) throw new Error("no result");
+  if (result.isError === true) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    const message = content
+      .map((part: unknown) =>
+        isRecord(part) && typeof part.text === "string" ? part.text : "",
+      )
+      .join("\n");
+    return { isError: true, message };
+  }
+  return { isError: false, structured: result.structuredContent };
+}
+
+/**
+ * The topic of allthings/<topic> from an evening's name: what follows "all
+ * things" ("All Things Agent Setups" is agent-setups), else the name less its
+ * city ("Effect San Francisco" is effect). Lowercase, words joined by "-".
+ */
+export function topicOf(name: string): string {
+  const plain = name
+    .replaceAll(/[^\p{L}\p{N}\s/&.+-]/gu, " ")
+    .replaceAll(/\s+/g, " ")
+    .trim();
+  const after = /^all\s*things\s*[/:–-]?\s*(.+)$/i.exec(plain)?.[1];
+  const topic = (after ?? plain.replace(/\s+(san francisco|sf)$/i, "")).trim();
+  const slug = topic
+    .toLowerCase()
+    .replaceAll(/\s+/g, "-")
+    .replaceAll(/[^\p{L}\p{N}.+-]/gu, "");
+  return slug === "" ? "_" : slug;
+}
+
+/** An EventSummary (`list_events`) or Event (`get_event`) as an Evening; null when it isn't one. */
+export function eveningOf(raw: unknown): Evening | null {
+  if (!isRecord(raw)) return null;
+  const { slug, name, url, status, startsAt, endsAt } = raw;
+  if (
+    typeof slug !== "string" ||
+    typeof name !== "string" ||
+    typeof url !== "string" ||
+    typeof startsAt !== "string" ||
+    typeof endsAt !== "string" ||
+    !Number.isFinite(Date.parse(startsAt)) ||
+    !Number.isFinite(Date.parse(endsAt))
+  ) {
+    return null;
+  }
+  const venue = isRecord(raw.venue) ? raw.venue : null;
+  const venueName = typeof venue?.name === "string" ? venue.name : null;
+  const address = typeof venue?.address === "string" ? venue.address : null;
+  const hosts = Array.isArray(raw.hosts)
+    ? raw.hosts.flatMap((host: unknown) =>
+        isRecord(host) && typeof host.name === "string" ? [host.name] : [],
+      )
+    : [];
+  const talks: EveningTalk[] = Array.isArray(raw.talks)
+    ? raw.talks.flatMap((talk: unknown) =>
+        isRecord(talk) && typeof talk.title === "string"
+          ? [
+              {
+                title: talk.title,
+                speakers: Array.isArray(talk.speakers)
+                  ? talk.speakers.flatMap((speaker: unknown) =>
+                      isRecord(speaker) && typeof speaker.name === "string"
+                        ? [speaker.name]
+                        : [],
+                    )
+                  : [],
+              },
+            ]
+          : [],
+      )
+    : [];
+  return {
+    slug,
+    name,
+    topic: topicOf(name),
+    url,
+    status: status === "live" || status === "past" ? status : "upcoming",
+    startsAt,
+    endsAt,
+    venueName,
+    address,
+    neighborhood: neighborhoodOf(address),
+    rsvpUrl: typeof raw.rsvpUrl === "string" ? raw.rsvpUrl : null,
+    recordingUrl:
+      typeof raw.recordingUrl === "string" ? raw.recordingUrl : null,
+    isHackathon: raw.isHackathon === true,
+    hosts,
+    talks,
+  };
+}
+
+/** The evenings of a `list_events` answer, in the server's order. */
+export function eveningsOf(structured: unknown): Evening[] {
+  if (!isRecord(structured) || !Array.isArray(structured.events)) {
+    throw new Error("list_events answered without events");
+  }
+  return structured.events.flatMap((raw: unknown) => {
+    const evening = eveningOf(raw);
+    return evening === null ? [] : [evening];
+  });
+}
+
+/** Where an evening stands at an instant. */
+export type Phase =
+  /** Ahead, on another day. */
+  | "upcoming"
+  /** Ahead, later today in San Francisco. */
+  | "today"
+  /** Started and not yet over. */
+  | "live"
+  /** Over. */
+  | "past";
+
+export function phaseOf(evening: Evening, now: number): Phase {
+  const starts = Date.parse(evening.startsAt);
+  const ends = Date.parse(evening.endsAt);
+  if (now >= ends) return "past";
+  if (now >= starts || evening.status === "live") return "live";
+  return isSameDay(starts, now) ? "today" : "upcoming";
+}
+
+/** The host to name: the hosting companies `get_event` gave, else the venue's name. */
+export function hostOf(evening: Evening): string | null {
+  if (evening.hosts.length > 0) return evening.hosts.join(" & ");
+  return evening.venueName;
+}
+
+/** The band's first slot: the date, the countdown on the day, or "live now". */
+export function whenOf(evening: Evening, now: number): string {
+  const starts = Date.parse(evening.startsAt);
+  const phase = phaseOf(evening, now);
+  if (phase === "live") return "live now";
+  if (phase === "today")
+    return `${isEveningStart(starts) ? "tonight" : "today"} · in ${untilOf(now, starts)}`;
+  if (phase === "upcoming") return `${dayOf(starts)} · ${clockOf(starts)}`;
+  return dayOf(starts);
+}
+
+/** The lockup, allthings/<topic>, with the cursor while the evening hasn't happened. */
+export function lockupOf(
+  evening: Evening,
+  now: number,
+  cursor: string,
+): string {
+  return `${WORDMARK}/${evening.topic}${phaseOf(evening, now) === "past" ? "" : cursor}`;
+}
+
+/** The sign-off after someone says they're in. */
+export function signOffOf(evening: Evening): string {
+  return `see you at/${evening.topic}`;
+}
+
+/** An address less its city, state and country: "201 Spear St 12th floor". */
+export function streetOf(address: string): string {
+  return address
+    .replace(/,\s*(san francisco|sf)\b.*$/i, "")
+    .replace(/^[^,0-9]+,\s*(?=\d)/, "")
+    .trim();
+}
+
+/** A URL as a person reads it: no scheme, no www, no trailing slash. */
+export function shortUrl(url: string): string {
+  return url
+    .replace(/^https?:\/\//, "")
+    .replace(/^www\./, "")
+    .replace(/\/$/, "");
+}
+
+/**
+ * The text `/at` prints, which Claude reads too: the lockup, when and where,
+ * who's on stage, and where to say you're in.
+ */
+export function cardText(evening: Evening, now: number): string {
+  const starts = Date.parse(evening.startsAt);
+  const ends = Date.parse(evening.endsAt);
+  const phase = phaseOf(evening, now);
+  const host = hostOf(evening);
+  const lines = [lockupOf(evening, now, "_")];
+  const when =
+    phase === "live"
+      ? `live now, until ${clockOf(ends)}`
+      : `${dayOf(starts)} · ${spanOf(starts, ends)}${phase === "today" ? ` · in ${untilOf(now, starts)}` : ""}`;
+  lines.push(
+    [when, evening.neighborhood, host === null ? null : `hosted at ${host}`]
+      .filter((part) => part !== null)
+      .join(" · "),
+  );
+  if (evening.address !== null) lines.push(streetOf(evening.address));
+  for (const talk of evening.talks) {
+    lines.push(
+      talk.speakers.length > 0
+        ? `· ${talk.title} — ${talk.speakers.join(", ")}`
+        : `· ${talk.title}`,
+    );
+  }
+  if (phase === "past") {
+    if (evening.recordingUrl !== null)
+      lines.push(`recording → ${evening.recordingUrl}`);
+  } else if (evening.rsvpUrl !== null) {
+    lines.push(`I'm in → ${evening.rsvpUrl}`);
+  }
+  lines.push(evening.url);
+  return lines.join("\n");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseUrl(text: string): URL | null {
+  try {
+    return new URL(text);
+  } catch {
+    return null;
+  }
+}
diff --git a/plugins/allthings/hooks/hooks.json b/plugins/allthings/hooks/hooks.json
new file mode 100644
index 00000000..7947b477
--- /dev/null
+++ b/plugins/allthings/hooks/hooks.json
@@ -0,0 +1,4 @@
+{
+  "description": "allthings/_ for Claude Code: tool rows in the slash grammar, the wandering spinner, the next evening's band, /at and /imin",
+  "modules": ["./register.tsx"]
+}
diff --git a/plugins/allthings/hooks/palette.ts b/plugins/allthings/hooks/palette.ts
new file mode 100644
index 00000000..04fbc09d
--- /dev/null
+++ b/plugins/allthings/hooks/palette.ts
@@ -0,0 +1,34 @@
+/**
+ * The brand's colors (brand/all-things.tokens.json), and which one the slash
+ * takes: Bridge on light grounds, Glow on Night and other dark ones.
+ */
+
+export const NIGHT = "#1B1729";
+export const PAPER = "#F4F1EC";
+export const INK = "#141210";
+export const BRIDGE = "#C0362C";
+export const GLOW = "#FF6A3D";
+export const LAVENDER = "#DACFFF";
+export const DUSK = "#D9D3E0";
+export const VIOLET = "#5B34D6";
+
+/**
+ * The slash's color for a Claude Code theme setting (`/config`'s `theme`
+ * row: `dark`, `light-daltonized`, a custom or plugin theme's id, `auto`).
+ * `auto` follows the terminal: COLORFGBG's background when it says, else dark.
+ */
+export function slashColorOf(
+  theme: unknown,
+  colorFgBg: string | undefined,
+): string {
+  const name = typeof theme === "string" ? theme.toLowerCase() : "";
+  if (/paper|light/.test(name)) return BRIDGE;
+  if (/night|dark/.test(name)) return GLOW;
+  return isLightTerminal(colorFgBg) ? BRIDGE : GLOW;
+}
+
+/** COLORFGBG is "fg;bg" in ANSI color numbers: 7 and 15 are light grounds. */
+function isLightTerminal(colorFgBg: string | undefined): boolean {
+  const background = colorFgBg?.split(";").at(-1);
+  return background === "7" || background === "15";
+}
diff --git a/plugins/allthings/hooks/register.tsx b/plugins/allthings/hooks/register.tsx
new file mode 100644
index 00000000..437841a4
--- /dev/null
+++ b/plugins/allthings/hooks/register.tsx
@@ -0,0 +1,673 @@
+/**
+ * allthings/_ for Claude Code: tool rows in the slash grammar, the spinner as
+ * the wordmark wandering the city, the next evening in a Night band above the
+ * prompt, and /at and /imin, which answer at once with no turn.
+ *
+ * Every hook here restyles; none hides what Claude Code shows. A failure to
+ * reach the site is quiet: no band, and a plain line from the commands.
+ *
+ * The engine reads `on(...)` and `$.noun.method(...)` from this source, so
+ * they are spelled in full, and the helpers that take `$` are top-level
+ * functions of this file.
+ */
+
+import { atom, read, update } from "claude-code";
+import type { CommandSpec, EngineInterface, Register } from "claude-code";
+
+import type { Card, Evening } from "../types";
+import { phraseAt, seedOf } from "./city";
+import {
+  cardText,
+  endpointOf,
+  eveningOf,
+  eveningsOf,
+  FRESH_MS,
+  GRACE_MS,
+  hostOf,
+  phaseOf,
+  shortUrl,
+  signOffOf,
+  streetOf,
+  TOOL_CALL_HEADERS,
+  toolAnswerOf,
+  toolCallBody,
+  whenOf,
+  WORDMARK,
+  type ToolAnswer,
+} from "./evenings";
+import {
+  BRIDGE,
+  DUSK,
+  GLOW,
+  LAVENDER,
+  NIGHT,
+  PAPER,
+  slashColorOf,
+  VIOLET,
+} from "./palette";
+import { rowOf } from "./rows";
+import { clockOf, dayOf, spanOf } from "./time";
+
+type Engine = EngineInterface;
+
+const nextEvening = atom({ plugin: "allthings", key: "next" } as const, null);
+const fetchedAt = atom({ plugin: "allthings", key: "fetchedAt" } as const, 0);
+const clock = atom({ plugin: "allthings", key: "now" } as const, 0);
+const tick = atom({ plugin: "allthings", key: "tick" } as const, 0);
+const clicked = atom({ plugin: "allthings", key: "clicked" } as const, []);
+const slash = atom({ plugin: "allthings", key: "slash" } as const, GLOW);
+const reduceMotion = atom(
+  { plugin: "allthings", key: "reduceMotion" } as const,
+  false,
+);
+const cards = atom({ plugin: "allthings", key: "cards" } as const, {});
+
+/** The cursor blinks once a second: on for half of it, off for the other. */
+export const BLINK_MS = 500;
+
+/** The band's clock, and the check for a stale or finished evening, move this often. */
+export const MINUTE_MS = 30_000;
+
+/** The spinner's line moves on to the next neighborhood every this many blinks (6 seconds). */
+export const PHRASE_TICKS = 12;
+
+/** After a failed refresh, wait this long before asking again for an evening that just ended. */
+const RETRY_MS = 5 * 60_000;
+
+/** How many /at cards the session keeps drawable. */
+const CARDS_KEPT = 20;
+
+/** The session's folder, to draw paths relative to it. */
+let cwd = "";
+/** Whether a main-loop turn is running, so the spinner's cursor blinks. */
+let isWorking = false;
+/** Where this turn's walk through the city starts. */
+let seed = 0;
+/** When the mod last asked the site, successfully or not. */
+let attemptedAt = 0;
+/** The refresh under way, which every caller meanwhile shares. */
+let refreshing: Promise<Evening | null | undefined> | null = null;
+/** Tool calls drawn inside an expanded group, whose rows carry their output. */
+const unfolded = new Set<string>();
+
+export const register: Register = (on) => {
+  on("session.start", async ($, e, next) => {
+    cwd = e.cwd;
+    const started = await next(e);
+    await loadSaved($);
+    await readSettings($);
+    await minute($, { refresh: false });
+    // Only a session someone watches draws the band and the cursor; a
+    // headless run (claude -p, the SDK) asks the site only when a command does.
+    if (e.isInteractive) {
+      $.clock.every(BLINK_MS, () => {
+        void blink($);
+      });
+      $.clock.every(MINUTE_MS, () => {
+        void minute($, { refresh: true });
+      });
+      // Ask the site once the session is up, never holding its start.
+      $.clock.after(1, () => {
+        void minute($, { refresh: true });
+      });
+    }
+    await offer($, {
+      name: "at",
+      description: "The next allthings evening, or any evening by its slug",
+      argumentHint: "[slug]",
+      immediate: true,
+    });
+    await offer($, {
+      name: "imin",
+      description: "Open the next allthings evening's page to say you're in",
+      immediate: true,
+    });
+    return started;
+  });
+
+  // /clear, /resume and /branch reset $.state without a new session.start.
+  on(
+    "classic.SessionStart",
+    { source: ["clear", "resume", "fork"] },
+    async ($, e, next) => {
+      const result = await next(e);
+      await loadSaved($);
+      await readSettings($);
+      await minute($, { refresh: false });
+      return result;
+    },
+  ).catch(($, e, beneath) => beneath(e));
+
+  on("config.set", { key: ["theme", "reduceMotion"] }, async ($, e, next) => {
+    const result = await next(e);
+    if (result.deny === undefined) await readSettings($);
+    return result;
+  }).catch(($, e, beneath) => beneath(e));
+
+  on("turn.start", async ($, e, next) => {
+    isWorking = true;
+    seed = seedOf(e.turnId);
+    return next(e);
+  });
+
+  on("turn.complete", async ($, e, next) => {
+    if (e.agentId === undefined) isWorking = false;
+    return next(e);
+  });
+
+  // The spinner: allthings/_ with its cursor, then a working verb somewhere in
+  // the city. Claude Code keeps drawing the elapsed time and tokens after it.
+  on("ui.render", { component: "Spinner" }, async ($, e, next) => {
+    const isStill = await read($, reduceMotion);
+    const t = await read($, tick);
+    const mark = `${WORDMARK}/${!isStill && t % 2 === 1 ? " " : "_"}`;
+    if (e.props.message !== null) {
+      return next({
+        ...e,
+        props: { ...e.props, message: `${mark} · ${e.props.message}` },
+      });
+    }
+    // The desktop's word says what the step is doing: keep it.
+    if (e.surface !== "terminal" && e.props.word !== "Working") {
+      return next({
+        ...e,
+        props: { ...e.props, word: `${mark} · ${e.props.word}` },
+      });
+    }
+    const phrase = phraseAt(seed + Math.floor(t / PHRASE_TICKS));
+    return next({ ...e, props: { ...e.props, word: `${mark} ${phrase}` } });
+  });
+
+  // An expanded group draws each call's output in its row: those rows stay
+  // Claude Code's own, so nothing is lost.
+  on("ui.render", { component: "ToolGroup" }, ($, e, next) => {
+    if (e.props.isExpanded) {
+      for (const call of e.props.calls) {
+        if (call.tool_use_id !== undefined) unfolded.add(call.tool_use_id);
+      }
+    }
+    return next(e);
+  });
+
+  // A tool call's row in the slash grammar: read/src/app.ts. The status dot,
+  // the error color and "Interrupted" stay; the result below is Claude Code's.
+  on("ui.render", { component: "ToolUse" }, async ($, e, next) => {
+    // The desktop's rows expand and collapse themselves: leave them be.
+    if (e.surface !== "terminal" || unfolded.has(e.props.tool_use_id))
+      return next(e);
+    const { Box, Text } = $.ui.resolve(e);
+    const row = rowOf(e.props.tool, e.props.input, cwd);
+    const color = await read($, slash);
+    const isFailed = e.props.isErrored || e.props.isInterrupted;
+    const isDim =
+      e.props.isRunning &&
+      !(await read($, reduceMotion)) &&
+      (await read($, tick)) % 2 === 1;
+    const dot = isFailed ? "error" : e.props.isRunning ? "inactive" : "success";
+    return (
+      <Box key={`row-${e.props.tool_use_id}`} flexDirection="column">
+        <Box flexDirection="row">
+          <Text color={dot} dimColor={isDim}>
+            {"⏺ "}
+          </Text>
+          <Text>
+            <Text bold>{row.verb}</Text>
+            <Text color={color}>/</Text>
+            {row.arg}
+            {row.detail === null ? null : (
+              <Text dimColor>{` (${row.detail})`}</Text>
+            )}
+          </Text>
+        </Box>
+        {e.props.isInterrupted ? (
+          <Text color="error">{"  ⎿  Interrupted"}</Text>
+        ) : null}
+      </Box>
+    );
+  });
+
+  // The band: the next evening on Night, and a button to say you're in.
+  on("ui.render", { component: "AbovePrompt" }, async ($, e, next) => {
+    if (e.props.hasSurvey) return next(e);
+    const evening = await read($, nextEvening);
+    if (evening === null) return next(e);
+    const now = await read($, clock);
+    const phase = phaseOf(evening, now);
+    if (phase === "past") return next(e);
+    const isIn = (await read($, clicked)).includes(evening.slug);
+    const isStill = await read($, reduceMotion);
+    const cursor = !isStill && (await read($, tick)) % 2 === 1 ? " " : "_";
+    const host = hostOf(evening);
+    const columns = e.props.bodyColumns;
+    const { Box, Text, Button } = $.ui.resolve(e);
+    return (
+      <Box
+        key="band"
+        flexDirection="row"
+        backgroundColor={NIGHT}
+        paddingX={1}
+        columnGap={2}
+      >
+        <Box flexGrow={1} flexShrink={1}>
+          <Text color={DUSK} wrap="truncate-end">
+            <Text
+              color={phase === "live" ? GLOW : DUSK}
+              bold={phase === "live"}
+            >
+              {whenOf(evening, now)}
+            </Text>
+            {" · "}
+            <Text color={PAPER} bold>
+              {WORDMARK}
+              <Text color={GLOW}>/</Text>
+              {`${evening.topic}${cursor}`}
+            </Text>
+            {evening.neighborhood !== null && columns >= 56 ? (
+              <Text color={LAVENDER}>{` · ${evening.neighborhood}`}</Text>
+            ) : null}
+            {host !== null && columns >= 80 ? ` · hosted at ${host}` : null}
+          </Text>
+        </Box>
+        {isIn ? (
+          <Text color={PAPER}>
+            see you at<Text color={GLOW}>/</Text>
+            {evening.topic}
+          </Text>
+        ) : evening.rsvpUrl === null ? null : (
+          <Button
+            key="imin"
+            label="I'm in →"
+            variant="primary"
+            onPress={() => sayImIn($, evening)}
+          />
+        )}
+      </Box>
+    );
+  });
+
+  on("command.run", { command: "at" }, async ($, e) => {
+    const slug = e.args.trim();
+    const endpoint = await endpointFor($);
+    if (endpoint === null) return { text: UNCONFIGURED };
+    let evening: Evening | null | undefined;
+    if (slug === "") {
+      const upcoming = await upcomingEvening($, true);
+      if (upcoming === undefined) return { text: unreachable(endpoint) };
+      if (upcoming === null) {
+        return { text: nothingAhead(endpoint) };
+      }
+      evening = (await eveningBySlug($, endpoint, upcoming.slug)) ?? upcoming;
+    } else {
+      evening = await eveningBySlug($, endpoint, slug);
+      if (evening === undefined) return { text: unreachable(endpoint) };
+      if (evening === null)
+        return { text: `no evening at ${slug}. /at shows the next one.` };
+    }
+    const now = await $.clock.now();
+    const card: Card = { evening, at: now };
+    await update($, cards, (kept) => keepCard(kept, slug, card));
+    return { text: cardText(evening, now) };
+  }).catch(() => ({ text: STUMBLED }));
+
+  on("command.run", { command: "imin" }, async ($) => {
+    const endpoint = await endpointFor($);
+    if (endpoint === null) return { text: UNCONFIGURED };
+    const upcoming = await upcomingEvening($, false);
+    if (upcoming === undefined) return { text: unreachable(endpoint) };
+    if (upcoming === null) {
+      return { text: nothingAhead(endpoint) };
+    }
+    if (upcoming.rsvpUrl === null) {
+      return {
+        text: `${upcoming.name} has no page to say you're in yet. ${upcoming.url}`,
+      };
+    }
+    const isOpened = await sayImIn($, upcoming);
+    return {
+      text: isOpened
+        ? `${signOffOf(upcoming)} · opened ${shortUrl(upcoming.rsvpUrl)}`
+        : `${signOffOf(upcoming)} · say you're in at ${upcoming.rsvpUrl}`,
+    };
+  }).catch(() => ({ text: STUMBLED }));
+
+  // /at's row as a card: the lockup with its slash, when and where, who's on
+  // stage, and the links. The text it draws from is the one Claude reads.
+  on(
+    "ui.render",
+    { component: "CommandOutput", props: { command: "at" } },
+    async ($, e, next) => {
+      if (e.props.isErrored) return next(e);
+      const card = (await read($, cards))[e.props.args.trim()];
+      if (card === undefined) return next(e);
+      const { evening, at } = card;
+      const color = await read($, slash);
+      const hoodColor = color === BRIDGE ? VIOLET : LAVENDER;
+      const phase = phaseOf(evening, at);
+      const starts = Date.parse(evening.startsAt);
+      const ends = Date.parse(evening.endsAt);
+      const host = hostOf(evening);
+      const action =
+        phase === "past"
+          ? evening.recordingUrl === null
+            ? null
+            : (["recording → ", evening.recordingUrl] as const)
+          : evening.rsvpUrl === null
+            ? null
+            : (["I'm in → ", evening.rsvpUrl] as const);
+      const { Box, Text, Link } = $.ui.resolve(e);
+      const linkTo = (href: string) => {
+        const safe = httpsHref(href);
+        return safe === null ? (
+          <Text>{href}</Text>
+        ) : (
+          <Link href={safe} label={shortUrl(href)} />
+        );
+      };
+      return (
+        <Box key="card" flexDirection="column">
+          <Text bold>
+            {WORDMARK}
+            <Text color={color}>/</Text>
+            {`${evening.topic}${phase === "past" ? "" : "_"}`}
+          </Text>
+          <Text>
+            <Text dimColor>
+              {phase === "live"
+                ? `live now, until ${clockOf(ends)}`
+                : `${dayOf(starts)} · ${spanOf(starts, ends)}`}
+            </Text>
+            {evening.neighborhood === null ? null : (
+              <Text color={hoodColor}>{` · ${evening.neighborhood}`}</Text>
+            )}
+            {host === null ? null : (
+              <Text dimColor>{` · hosted at ${host}`}</Text>
+            )}
+          </Text>
+          {evening.address === null ? null : (
+            <Text dimColor>{streetOf(evening.address)}</Text>
+          )}
+          {evening.talks.map((talk) => (
+            <Text>
+              {"· "}
+              {talk.title}
+              {talk.speakers.length > 0 ? (
+                <Text dimColor>{` — ${talk.speakers.join(", ")}`}</Text>
+              ) : null}
+            </Text>
+          ))}
+          {action === null ? null : (
+            <Text>
+              {action[0]}
+              {linkTo(action[1])}
+            </Text>
+          )}
+          <Text dimColor>{linkTo(evening.url)}</Text>
+        </Box>
+      );
+    },
+  );
+};
+
+/** Registers a command; a name a built-in or another plugin already took costs only that command. */
+async function offer($: Engine, command: CommandSpec): Promise<void> {
+  try {
+    await $.command.register(command);
+  } catch {
+    // The other command and the rest of the mod still run.
+  }
+}
+
+/** Copies what earlier sessions saved into the session's state. */
+async function loadSaved($: Engine): Promise<void> {
+  const saved = await stored($, "next");
+  if (isRecord(saved) && typeof saved.fetchedAt === "number") {
+    const evening = eveningOf(saved.raw);
+    await update($, nextEvening, () => evening);
+    await update($, fetchedAt, () => Number(saved.fetchedAt));
+  }
+  const said = await stored($, "clicked");
+  if (Array.isArray(said)) {
+    const slugs = said.filter(
+      (slug): slug is string => typeof slug === "string",
+    );
+    await update($, clicked, () => slugs);
+  }
+}
+
+/** The theme's slash color and the reduce-motion setting, from /config. */
+async function readSettings($: Engine): Promise<void> {
+  let rows: Awaited<ReturnType<Engine["config"]["list"]>> = [];
+  try {
+    rows = await $.config.list();
+  } catch {
+    // No settings to read: the defaults, Glow and motion, stand.
+  }
+  const theme = rows.find((row) => row.key === "theme")?.value;
+  const still = rows.find((row) => row.key === "reduceMotion")?.value === true;
+  const colorFgBg = await $.env.get("COLORFGBG");
+  await update($, slash, () => slashColorOf(theme, colorFgBg));
+  await update($, reduceMotion, () => still);
+}
+
+/** Half a second on: the cursor blinks while a turn runs or the band shows. */
+async function blink($: Engine): Promise<void> {
+  if (await read($, reduceMotion)) return;
+  if (!isWorking && (await read($, nextEvening)) === null) return;
+  await update($, tick, (n) => (n + 1) % 1_000_000);
+}
+
+/** The band's clock, and a refresh when the evening is stale or over. */
+async function minute($: Engine, options: { refresh: boolean }): Promise<void> {
+  const now = await $.clock.now();
+  await update($, clock, () => now);
+  if (!options.refresh) return;
+  const evening = await read($, nextEvening);
+  const lastAsked = Math.max(await read($, fetchedAt), attemptedAt);
+  const isStale = now - lastAsked >= FRESH_MS;
+  const isOver =
+    evening !== null &&
+    Date.parse(evening.endsAt) <= now &&
+    now - attemptedAt >= RETRY_MS;
+  if (isStale || isOver) await refresh($);
+}
+
+/** The next evening: the cached one while fresh, else the site's; undefined when the site can't be reached. */
+async function upcomingEvening(
+  $: Engine,
+  isForced: boolean,
+): Promise<Evening | null | undefined> {
+  const now = await $.clock.now();
+  const cached = await read($, nextEvening);
+  const isFresh = now - (await read($, fetchedAt)) < FRESH_MS;
+  const isCurrent = cached === null || Date.parse(cached.endsAt) > now;
+  if (!isForced && isFresh && isCurrent) return cached;
+  return refresh($);
+}
+
+/**
+ * Asks the site for the next evening (list_events, upcoming, limit 1) and
+ * keeps it; a call while one is under way gets that one's answer, so a
+ * timer and a command never ask twice. Resolves undefined when the site
+ * couldn't be reached.
+ */
+function refresh($: Engine): Promise<Evening | null | undefined> {
+  refreshing ??= askForNext($).finally(() => {
+    refreshing = null;
+  });
+  return refreshing;
+}
+
+/**
+ * One request for the next evening, kept in $.state and the store. On a
+ * failure the cached evening stays for GRACE_MS, then the band goes quiet.
+ */
+async function askForNext($: Engine): Promise<Evening | null | undefined> {
+  const now = await $.clock.now();
+  attemptedAt = now;
+  const endpoint = await endpointFor($);
+  try {
+    if (endpoint === null) throw new Error("no MCP server configured");
+    const answer = await callTool($, endpoint, "list_events", {
+      when: "upcoming",
+      limit: 1,
+    });
+    if (answer.isError) throw new Error(answer.message);
+    const [first = null] = eveningsOf(answer.structured);
+    await update($, nextEvening, () => first);
+    await update($, fetchedAt, () => now);
+    await save($, "next", { raw: rawOf(first), fetchedAt: now });
+    return first;
+  } catch {
+    if (now - (await read($, fetchedAt)) >= GRACE_MS) {
+      await update($, nextEvening, () => null);
+    }
+    return undefined;
+  }
+}
+
+/** One evening by slug (get_event): null when the site has none by it, undefined when unreachable. */
+async function eveningBySlug(
+  $: Engine,
+  endpoint: string,
+  slug: string,
+): Promise<Evening | null | undefined> {
+  try {
+    const answer = await callTool($, endpoint, "get_event", { slug });
+    if (answer.isError)
+      return answer.message.startsWith("No published event") ? null : undefined;
+    return eveningOf(answer.structured);
+  } catch {
+    return undefined;
+  }
+}
+
+/** One tool call to the plugin's MCP server over HTTP, stateless. */
+async function callTool(
+  $: Engine,
+  endpoint: string,
+  name: string,
+  args: Record<string, unknown>,
+): Promise<ToolAnswer> {
+  const response = await $.http.fetch(endpoint, {
+    method: "POST",
+    headers: { ...TOOL_CALL_HEADERS },
+    body: toolCallBody(name, args),
+  });
+  if (!response.ok) throw new Error(`${endpoint} answered ${response.status}`);
+  return toolAnswerOf(response.text, response.headers["content-type"] ?? "");
+}
+
+/** The MCP server's URL as this plugin configures it, read fresh so a config change carries over. */
+async function endpointFor($: Engine): Promise<string | null> {
+  for (const file of [".mcp.json", "mcp.json"]) {
+    try {
+      const endpoint = endpointOf(await $.fs.read(`${$.plugin.root}/${file}`));
+      if (endpoint !== null) return endpoint;
+    } catch {
+      // No such file: try the next.
+    }
+  }
+  return null;
+}
+
+/** Opens the evening's page, and remembers that this person said they're in. */
+async function sayImIn($: Engine, evening: Evening): Promise<boolean> {
+  if (evening.rsvpUrl === null) return false;
+  const isOpened = await openUrl($, evening.rsvpUrl);
+  if (!isOpened) $.ui.toast(`I'm in → ${evening.rsvpUrl}`);
+  await update($, clicked, (slugs) =>
+    slugs.includes(evening.slug) ? slugs : [...slugs, evening.slug],
+  );
+  await save($, "clicked", await read($, clicked));
+  return isOpened;
+}
+
+/** A value an earlier session kept, or undefined when the store can't be read. */
+async function stored($: Engine, key: string): Promise<unknown> {
+  try {
+    return await $.store.get(key);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Keeps a value for later sessions; a store that can't be written costs only that. */
+async function save($: Engine, key: string, value: unknown): Promise<void> {
+  try {
+    await $.store.set(key, value);
+  } catch {
+    // The session goes on with what it holds in $.state.
+  }
+}
+
+/** Opens a URL in the person's browser: macOS, then Linux, then Windows. */
+async function openUrl($: Engine, url: string): Promise<boolean> {
+  for (const argv of [
+    ["open", url],
+    ["xdg-open", url],
+    ["cmd", "/c", "start", "", url],
+  ]) {
+    try {
+      const run = await $.process.run(argv, { timeoutMs: 10_000 });
+      if (run.exitCode === 0) return true;
+    } catch {
+      // Not this platform's opener.
+    }
+  }
+  return false;
+}
+
+/** What the commands say when the plugin names no MCP server. */
+const UNCONFIGURED =
+  "the allthings MCP server isn't configured in this plugin.";
+
+/** What the commands say when something unexpected stopped them. */
+const STUMBLED = "allthings couldn't answer just now. try again in a minute.";
+
+function nothingAhead(endpoint: string): string {
+  return `no evening on the calendar right now. ${new URL(endpoint).origin} has what's next.`;
+}
+
+function unreachable(endpoint: string): string {
+  return `couldn't reach ${new URL(endpoint).host} just now. try again in a minute.`;
+}
+
+function keepCard(
+  kept: Readonly<Record<string, Card>>,
+  key: string,
+  card: Card,
+): Record<string, Card> {
+  const entries = Object.entries(kept).filter(([name]) => name !== key);
+  return Object.fromEntries([...entries.slice(-(CARDS_KEPT - 1)), [key, card]]);
+}
+
+/** An Evening as the store keeps it: in the site's own shape, read back through eveningOf. */
+function rawOf(evening: Evening | null): unknown {
+  if (evening === null) return null;
+  return {
+    slug: evening.slug,
+    name: evening.name,
+    url: evening.url,
+    status: evening.status,
+    startsAt: evening.startsAt,
+    endsAt: evening.endsAt,
+    venue: { name: evening.venueName, address: evening.address },
+    rsvpUrl: evening.rsvpUrl,
+    recordingUrl: evening.recordingUrl,
+    isHackathon: evening.isHackathon,
+  };
+}
+
+/** A URL a Link takes: https only, spelled as URL spells it. */
+function httpsHref(href: string): string | null {
+  try {
+    const url = new URL(href);
+    return url.protocol === "https:" ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
diff --git a/plugins/allthings/hooks/rows.ts b/plugins/allthings/hooks/rows.ts
new file mode 100644
index 00000000..20d45046
--- /dev/null
+++ b/plugins/allthings/hooks/rows.ts
@@ -0,0 +1,215 @@
+/**
+ * A tool call's row in the slash grammar: a lowercase verb, a slash, then
+ * what it acts on (read/src/app.ts, bash/bun test, search/"curation"). The
+ * detail carries the rest of what Claude Code's own row shows, drawn dim, so
+ * the restyle hides nothing.
+ */
+
+export type Row = {
+  verb: string;
+  arg: string;
+  /** What else the call says (a path, a glob, an agent type), or null. */
+  detail: string | null;
+};
+
+/** Longest a single input value is drawn in a detail, as Claude Code clips them too. */
+const VALUE_MAX = 120;
+
+/** The row for one call: the tool's name as Claude Code reports it, its input, the session's folder. */
+export function rowOf(tool: string, input: unknown, cwd: string): Row {
+  const args = isRecord(input) ? input : {};
+  const text = (key: string): string | null => {
+    const value = args[key];
+    return typeof value === "string" && value !== "" ? value : null;
+  };
+  const path = (key: string): string => relative(text(key) ?? "", cwd);
+  const details = (...parts: (string | null | false)[]): string | null => {
+    const kept = parts.filter(
+      (part): part is string => typeof part === "string" && part !== "",
+    );
+    return kept.length > 0 ? kept.join(" · ") : null;
+  };
+
+  switch (tool) {
+    case "Read":
+      return {
+        verb: "read",
+        arg: path("file_path"),
+        detail: details(
+          rangeOf(args),
+          text("pages") && `pages ${text("pages")}`,
+        ),
+      };
+    case "Edit":
+      return {
+        verb: "edit",
+        arg: path("file_path"),
+        detail: details(args.replace_all === true && "every match"),
+      };
+    case "MultiEdit": {
+      const edits = Array.isArray(args.edits) ? args.edits.length : 0;
+      return {
+        verb: "edit",
+        arg: path("file_path"),
+        detail: details(edits > 0 && `${edits} edits`),
+      };
+    }
+    case "Write":
+      return { verb: "write", arg: path("file_path"), detail: null };
+    case "NotebookEdit":
+      return {
+        verb: "edit",
+        arg: path("notebook_path"),
+        detail: details(
+          text("cell_id") && `cell ${text("cell_id")}`,
+          text("edit_mode"),
+        ),
+      };
+    case "Bash":
+      return {
+        verb: "bash",
+        arg: text("command") ?? "",
+        detail: details(args.run_in_background === true && "in the background"),
+      };
+    case "Grep":
+      return {
+        verb: "search",
+        arg: quoted(text("pattern") ?? ""),
+        detail: details(
+          text("path") && `in ${relative(text("path") ?? "", cwd)}`,
+          text("glob"),
+          text("type") && `type ${text("type")}`,
+        ),
+      };
+    case "Glob":
+      return {
+        verb: "find",
+        arg: text("pattern") ?? "",
+        detail: details(
+          text("path") && `in ${relative(text("path") ?? "", cwd)}`,
+        ),
+      };
+    case "WebFetch":
+      return { verb: "fetch", arg: pageOf(text("url") ?? ""), detail: null };
+    case "WebSearch":
+      return {
+        verb: "search",
+        arg: quoted(text("query") ?? ""),
+        detail: "the web",
+      };
+    case "Agent":
+    case "Task":
+      return {
+        verb: "agent",
+        arg: text("description") ?? text("name") ?? "",
+        detail: details(
+          text("subagent_type"),
+          args.run_in_background === true && "in the background",
+        ),
+      };
+    case "Skill":
+      return {
+        verb: "skill",
+        arg: text("skill") ?? text("command") ?? text("name") ?? "",
+        detail: details(text("args")),
+      };
+    case "TodoWrite": {
+      const todos = Array.isArray(args.todos) ? args.todos.length : 0;
+      return {
+        verb: "todo",
+        arg: `${todos} ${todos === 1 ? "item" : "items"}`,
+        detail: null,
+      };
+    }
+    default:
+      return tool.startsWith("mcp__")
+        ? mcpRowOf(tool, args)
+        : genericRowOf(tool, args);
+  }
+}
+
+/** An MCP tool, mcp__<server>__<tool>, reads as <server>/<tool> with its arguments. */
+function mcpRowOf(tool: string, args: Record<string, unknown>): Row {
+  const [, server = "", name = ""] = /^mcp__(.+?)__(.+)$/.exec(tool) ?? [];
+  // A plugin's server is plugin_<plugin>_<server>; the server's own name reads best.
+  const plugin = /^plugin_[^_]+_(.+)$/.exec(server)?.[1];
+  return {
+    verb: lower(plugin ?? server),
+    arg: name,
+    detail: summaryOf(args),
+  };
+}
+
+/** Any other tool: its name in lowercase words, and its input in brief. */
+function genericRowOf(tool: string, args: Record<string, unknown>): Row {
+  const verb = lower(tool);
+  const summary = summaryOf(args);
+  return { verb, arg: summary ?? "", detail: null };
+}
+
+/** "lines 10–59" for a Read with an offset or a limit. */
+function rangeOf(args: Record<string, unknown>): string | null {
+  const offset = typeof args.offset === "number" ? args.offset : null;
+  const limit = typeof args.limit === "number" ? args.limit : null;
+  if (offset === null && limit === null) return null;
+  const first = offset ?? 1;
+  return limit === null
+    ? `from line ${first}`
+    : `lines ${first}–${first + limit - 1}`;
+}
+
+/** An input in brief: each simple value as key: value. */
+function summaryOf(args: Record<string, unknown>): string | null {
+  const parts = Object.entries(args).flatMap(([key, value]) => {
+    if (typeof value === "string") return [`${key}: ${clip(value)}`];
+    if (typeof value === "number" || typeof value === "boolean")
+      return [`${key}: ${String(value)}`];
+    if (Array.isArray(value))
+      return [
+        `${key}: ${value.length} ${value.length === 1 ? "item" : "items"}`,
+      ];
+    return [];
+  });
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+
+/** A path inside the session's folder, relative to it; any other path as given. */
+export function relative(path: string, cwd: string): string {
+  if (cwd === "" || path === "") return path;
+  const base = cwd.endsWith("/") ? cwd : `${cwd}/`;
+  if (path.startsWith(base)) return path.slice(base.length);
+  return path === cwd ? "." : path;
+}
+
+/** A URL as its host and path: allthings.dev/events. */
+export function pageOf(url: string): string {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.host.replace(/^www\./, "");
+    const rest = `${parsed.pathname === "/" ? "" : parsed.pathname}${parsed.search}`;
+    return `${host}${rest}`;
+  } catch {
+    return url;
+  }
+}
+
+/** "ExitPlanMode" reads as exit-plan-mode, "list_events" as itself. */
+function lower(name: string): string {
+  return name
+    .replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+    .toLowerCase();
+}
+
+function quoted(text: string): string {
+  return `"${text}"`;
+}
+
+function clip(text: string): string {
+  const line = text.replaceAll(/\s+/g, " ").trim();
+  return line.length > VALUE_MAX ? `${line.slice(0, VALUE_MAX - 1)}…` : line;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
diff --git a/plugins/allthings/hooks/time.ts b/plugins/allthings/hooks/time.ts
new file mode 100644
index 00000000..d4748940
--- /dev/null
+++ b/plugins/allthings/hooks/time.ts
@@ -0,0 +1,108 @@
+/**
+ * San Francisco time, worked out by hand: the US rules for Pacific time
+ * (UTC-8, and UTC-7 from the second Sunday of March at 2am to the first
+ * Sunday of November at 2am), so nothing depends on the runtime's time zone
+ * data. Evenings carry `timeZone: "America/Los_Angeles"`.
+ */
+
+const HOUR = 3_600_000;
+const MINUTE = 60_000;
+
+const WEEKDAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"] as const;
+const MONTHS = [
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "may",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "oct",
+  "nov",
+  "dec",
+] as const;
+
+/** The day of the month of the nth Sunday (1-based) of a month, in UTC terms. */
+function nthSunday(year: number, month: number, n: number): number {
+  const first = new Date(Date.UTC(year, month, 1)).getUTCDay();
+  return 1 + ((7 - first) % 7) + (n - 1) * 7;
+}
+
+/** Pacific time's offset from UTC at an instant, in hours: -7 or -8. */
+export function pacificOffset(ms: number): number {
+  const year = new Date(ms).getUTCFullYear();
+  // 2am PST is 10:00 UTC; 2am PDT is 09:00 UTC.
+  const starts = Date.UTC(year, 2, nthSunday(year, 2, 2), 10);
+  const ends = Date.UTC(year, 10, nthSunday(year, 10, 1), 9);
+  return ms >= starts && ms < ends ? -7 : -8;
+}
+
+/** An instant's wall clock in San Francisco, read through UTC getters. */
+export type Wall = {
+  year: number;
+  month: number;
+  day: number;
+  weekday: number;
+  hour: number;
+  minute: number;
+};
+
+export function pacific(ms: number): Wall {
+  const shifted = new Date(ms + pacificOffset(ms) * HOUR);
+  return {
+    year: shifted.getUTCFullYear(),
+    month: shifted.getUTCMonth(),
+    day: shifted.getUTCDate(),
+    weekday: shifted.getUTCDay(),
+    hour: shifted.getUTCHours(),
+    minute: shifted.getUTCMinutes(),
+  };
+}
+
+/** Whether two instants fall on the same San Francisco calendar day. */
+export function isSameDay(a: number, b: number): boolean {
+  const x = pacific(a);
+  const y = pacific(b);
+  return x.year === y.year && x.month === y.month && x.day === y.day;
+}
+
+/** "thu oct 9" */
+export function dayOf(ms: number): string {
+  const wall = pacific(ms);
+  return `${WEEKDAYS[wall.weekday]} ${MONTHS[wall.month]} ${wall.day}`;
+}
+
+/** "5:30pm", or "6pm" on the hour. */
+export function clockOf(ms: number): string {
+  const { hour, minute } = pacific(ms);
+  const twelve = hour % 12 === 0 ? 12 : hour % 12;
+  const minutes = minute === 0 ? "" : `:${String(minute).padStart(2, "0")}`;
+  return `${twelve}${minutes}${hour < 12 ? "am" : "pm"}`;
+}
+
+/** "5:30–8:30pm", or "11am–2pm" across noon. */
+export function spanOf(startMs: number, endMs: number): string {
+  const start = clockOf(startMs);
+  const end = clockOf(endMs);
+  const startMeridiem = start.slice(-2);
+  return startMeridiem === end.slice(-2)
+    ? `${start.slice(0, -2)}–${end}`
+    : `${start}–${end}`;
+}
+
+/** Whether an evening counts as one by the brand's rule: it starts at 4pm or later, or before 5am. */
+export function isEveningStart(ms: number): boolean {
+  const { hour } = pacific(ms);
+  return hour >= 16 || hour < 5;
+}
+
+/** "2h 14m", "45m", or "1m" for anything under a minute. */
+export function untilOf(fromMs: number, toMs: number): string {
+  const minutes = Math.max(1, Math.ceil((toMs - fromMs) / MINUTE));
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  if (hours === 0) return `${rest}m`;
+  return rest === 0 ? `${hours}h` : `${hours}h ${rest}m`;
+}
diff --git a/plugins/allthings/output-styles/allthings.md b/plugins/allthings/output-styles/allthings.md
new file mode 100644
index 00000000..c20f0cec
--- /dev/null
+++ b/plugins/allthings/output-styles/allthings.md
@@ -0,0 +1,35 @@
+---
+name: allthings
+description: Talk like the allthings community: plain, warm, specific, lowercase where natural, with San Francisco's neighborhoods by name
+keep-coding-instructions: true
+---
+
+# allthings
+
+You are working with someone from allthings, an open community for people who build software in San Francisco. Keep doing the engineering exactly as you would; this style changes how you talk, never how you code.
+
+## Voice
+
+- Plain, warm, specific, a little dry. Sound like the friend who knows the good evenings, not like an events company or a hype account.
+- Lowercase where it reads naturally: short replies, status lines, headings you write yourself. Keep the case of code, identifiers, file names, commands, product names and proper nouns exactly as they are.
+- Say each thing once. No exclamation-mark enthusiasm, no hype words ("amazing", "vibrant", "excited to"), no emoji.
+- Name the place when a place comes up: SoMa, the Mission, Dogpatch, FiDi, the East Cut, Potrero Hill, Hayes Valley. Use the names locals use, never "downtown SF" or "the Bay Area tech scene".
+
+## Community words
+
+| Say                                | Not                               |
+| ---------------------------------- | --------------------------------- |
+| evenings                           | events, programming               |
+| I'm in                             | RSVP, register now, sign up       |
+| hosted at CodeRabbit · hosts       | sponsored by, sponsors, partners  |
+| who's on stage and what they built | thought leaders, industry experts |
+| talk between evenings on discord   | join our vibrant community        |
+
+- Never write "RSVP", in any case or form. Someone says "I'm in" on the evening's page.
+- The name is allthings, one word, lowercase. An evening is allthings/<topic> (allthings/effect); the master wordmark is allthings/\_.
+- "see you at/<topic>" is the sign-off, and only after someone has said they're in.
+- Hosting companies give the space, food and drinks. They are hosts, never sponsors.
+
+## When the work is code
+
+Code, commit messages, pull request text and documentation follow the repository's own conventions, not this voice. Explanations around them can be in it.
diff --git a/plugins/allthings/plugin.json b/plugins/allthings/plugin.json
index c03414ad..44a89d71 100644
--- a/plugins/allthings/plugin.json
+++ b/plugins/allthings/plugin.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "allthings",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Find allthings evenings in San Francisco, for people who build software: what's coming up, who's on stage and what they built, who's hosting, and where to say you're in.",
   "author": {
     "name": "allthings",
diff --git a/plugins/allthings/tests/band.test.ts b/plugins/allthings/tests/band.test.ts
new file mode 100644
index 00000000..df55b0b7
--- /dev/null
+++ b/plugins/allthings/tests/band.test.ts
@@ -0,0 +1,304 @@
+import { describe, expect, test } from "claude-code/testing";
+
+import { GLOW, NIGHT } from "../hooks/palette";
+import {
+  AT,
+  BAND,
+  elementsOf,
+  MCP_JSON,
+  SESSION,
+  SUMMARY,
+  textOf,
+  world,
+} from "./fixtures";
+
+const SURFACES = ["terminal", "desktop"] as const;
+const MINUTE = 60_000;
+
+describe("the next evening's band", () => {
+  test("none: with no evening ahead, the band is Claude Code's", async ($, on) => {
+    const w = world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    expect(w.requests).toEqual([
+      {
+        url: "https://allthings.dev/mcp",
+        tool: "list_events",
+        args: { when: "upcoming", limit: 1 },
+      },
+    ]);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(await ui.find({ key: "band" })).toBeUndefined();
+    expect(await ui.find({ text: "drawn by Claude Code" })).toBeDefined();
+  });
+
+  test("none: offline, it fails quietly with no band and no toast", async ($, on) => {
+    const w = world(on, {
+      site: { upcoming: [SUMMARY], isDown: true },
+      now: AT.upcoming,
+    });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(await ui.find({ key: "band" })).toBeUndefined();
+    expect(w.toasts).toEqual([]);
+  });
+
+  test("upcoming: date · allthings/<topic>_ · neighborhood · host, and I'm in, on Night", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    for (const surface of SURFACES) {
+      const ui = await $.ui.mount({ ...BAND, surface });
+      const band = await ui.find({ key: "band" });
+      expect(band?.props).toMatchObject({ backgroundColor: NIGHT });
+      expect(textOf(band)).toBe(
+        "thu oct 15 · 5:30pm · allthings/agent-setups_ · FiDi · hosted at SentryI'm in →",
+      );
+      expect(await ui.find({ key: "imin" })).toMatchObject({
+        type: "Button",
+        props: { label: "I'm in →" },
+      });
+      const slash = elementsOf(band).find((element) => textOf(element) === "/");
+      expect(slash?.props).toMatchObject({ color: GLOW });
+      await ui.unmount();
+    }
+  });
+
+  test("upcoming: the cursor blinks once a second", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(textOf(await ui.find({ key: "band" }))).toContain("agent-setups_");
+    await w.clock.advance(500);
+    expect(textOf(await ui.find({ key: "band" }))).toContain(
+      "agent-setups  · FiDi",
+    );
+    await w.clock.advance(500);
+    expect(textOf(await ui.find({ key: "band" }))).toContain("agent-setups_");
+  });
+
+  test("upcoming: a narrow band drops the host, then the neighborhood", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const at = async (bodyColumns: number) => {
+      const ui = await $.ui.mount({
+        ...BAND,
+        surface: "terminal",
+        props: { ...BAND.props, bodyColumns },
+      });
+      const text = textOf(await ui.find({ key: "band" }));
+      await ui.unmount();
+      return text;
+    };
+    expect(await at(70)).toBe(
+      "thu oct 15 · 5:30pm · allthings/agent-setups_ · FiDiI'm in →",
+    );
+    expect(await at(50)).toBe(
+      "thu oct 15 · 5:30pm · allthings/agent-setups_I'm in →",
+    );
+  });
+
+  test("today: a countdown in place of the date, moving with the clock", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.today });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const before = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(textOf(await before.find({ key: "band" }))).toStartWith(
+      "tonight · in 4h 30m · allthings/agent-setups_",
+    );
+    // Off screen while the half hour passes, so its blinks draw nothing.
+    await before.unmount();
+    await w.clock.advance(30 * MINUTE);
+    const after = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(textOf(await after.find({ key: "band" }))).toStartWith(
+      "tonight · in 4h · allthings/agent-setups_",
+    );
+  });
+
+  test("live: during the evening, live now in Glow", async ($, on) => {
+    const w = world(on, {
+      site: { upcoming: [{ ...SUMMARY, status: "live" }] },
+      now: AT.live,
+    });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    const band = await ui.find({ key: "band" });
+    expect(textOf(band)).toStartWith("live now · allthings/agent-setups_");
+    const live = elementsOf(band).find(
+      (element) => textOf(element) === "live now",
+    );
+    expect(live?.props).toMatchObject({ color: GLOW, bold: true });
+  });
+
+  test("after the evening, the band goes and the next one is asked for", async ($, on) => {
+    // An evening that ends five minutes from now.
+    const ending = {
+      ...SUMMARY,
+      endsAt: new Date(AT.live + 5 * MINUTE).toISOString(),
+    };
+    const w = world(on, { site: { upcoming: [ending] }, now: AT.live });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    await w.clock.advance(11 * MINUTE);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(await ui.find({ key: "band" })).toBeUndefined();
+    expect(
+      w.requests.filter((request) => request.tool === "list_events").length,
+    ).toBeGreaterThan(1);
+  });
+
+  test("after-click: I'm in opens the Luma page, and the band says see you at/<topic>", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    await ui.press({ key: "imin" });
+    expect(w.opened).toEqual([["open", SUMMARY.rsvpUrl]]);
+    const band = await ui.find({ key: "band" });
+    expect(textOf(band)).toBe(
+      "thu oct 15 · 5:30pm · allthings/agent-setups_ · FiDi · hosted at Sentrysee you at/agent-setups",
+    );
+    expect(await ui.find({ key: "imin" })).toBeUndefined();
+    expect(w.stored.get("clicked")).toEqual([SUMMARY.slug]);
+  });
+
+  test("after-click: a later session remembers", async ($, on) => {
+    const w = world(on, {
+      site: { upcoming: [SUMMARY] },
+      now: AT.upcoming,
+      stored: { clicked: [SUMMARY.slug] },
+    });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(textOf(await ui.find({ key: "band" }))).toEndWith(
+      "see you at/agent-setups",
+    );
+  });
+
+  test("a survey has the band to itself", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({
+      ...BAND,
+      surface: "terminal",
+      props: { ...BAND.props, hasSurvey: true },
+    });
+    expect(await ui.find({ key: "band" })).toBeUndefined();
+  });
+});
+
+describe("the band's data", () => {
+  test("refreshes about every 30 minutes, not more", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    expect(w.requests).toHaveLength(1);
+    await w.clock.advance(29 * MINUTE);
+    expect(w.requests).toHaveLength(1);
+    await w.clock.advance(2 * MINUTE);
+    expect(w.requests).toHaveLength(2);
+  });
+
+  test("a headless run asks the site nothing until a command does", async ($, on) => {
+    const w = world(on, { site: { upcoming: [SUMMARY] }, now: AT.upcoming });
+    await $.session.start({ ...SESSION, isInteractive: false });
+    await w.clock.advance(60 * MINUTE);
+    expect(w.requests).toEqual([]);
+  });
+
+  test("a fresh cache from the store draws at once, with no request", async ($, on) => {
+    const w = world(on, {
+      site: { upcoming: [SUMMARY] },
+      now: AT.upcoming,
+      stored: { next: { raw: SUMMARY, fetchedAt: AT.upcoming - 10 * MINUTE } },
+    });
+    await $.session.start(SESSION);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(textOf(await ui.find({ key: "band" }))).toContain(
+      "allthings/agent-setups_",
+    );
+    await w.clock.advance(1);
+    expect(w.requests).toEqual([]);
+  });
+
+  test("offline, a cache from the last two hours keeps the band", async ($, on) => {
+    const w = world(on, {
+      site: { upcoming: [SUMMARY], isDown: true },
+      now: AT.upcoming,
+      stored: { next: { raw: SUMMARY, fetchedAt: AT.upcoming - 60 * MINUTE } },
+    });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(await ui.find({ key: "band" })).toBeDefined();
+  });
+
+  test("offline, an older cache goes quiet", async ($, on) => {
+    const w = world(on, {
+      site: { upcoming: [SUMMARY], isDown: true },
+      now: AT.upcoming,
+      stored: {
+        next: { raw: SUMMARY, fetchedAt: AT.upcoming - 3 * 60 * MINUTE },
+      },
+    });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(await ui.find({ key: "band" })).toBeUndefined();
+  });
+
+  test("a store that can't be written doesn't cost the band", async ($, on) => {
+    const w = world(on, {
+      site: { upcoming: [SUMMARY] },
+      now: AT.upcoming,
+      isStoreDown: true,
+    });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(textOf(await ui.find({ key: "band" }))).toContain(
+      "allthings/agent-setups_",
+    );
+    await ui.press({ key: "imin" });
+    expect(textOf(await ui.find({ key: "band" }))).toEndWith(
+      "see you at/agent-setups",
+    );
+  });
+
+  test("comes from the plugin's configured MCP URL, so it moves with the config", async ($, on) => {
+    // A local server in place of the site, as a developer points the config.
+    const moved = MCP_JSON.replace(
+      "https://allthings.dev/mcp",
+      "http://localhost:8787/mcp",
+    );
+    const w = world(on, {
+      site: { upcoming: [SUMMARY] },
+      now: AT.upcoming,
+      mcpJson: moved,
+    });
+    await $.session.start(SESSION);
+    await w.clock.advance(1);
+    expect(w.requests.map((request) => request.url)).toEqual([
+      "http://localhost:8787/mcp",
+    ]);
+  });
+
+  test("/clear keeps the band, from what the store holds", async ($, on) => {
+    world(on, {
+      site: { upcoming: [SUMMARY] },
+      now: AT.upcoming,
+      stored: { next: { raw: SUMMARY, fetchedAt: AT.upcoming - MINUTE } },
+    });
+    await $.classic.SessionStart({ source: "clear" });
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    expect(textOf(await ui.find({ key: "band" }))).toContain(
+      "allthings/agent-setups_",
+    );
+  });
+});
diff --git a/plugins/allthings/tests/commands.test.ts b/plugins/allthings/tests/commands.test.ts
new file mode 100644
index 00000000..028b6d9c
--- /dev/null
+++ b/plugins/allthings/tests/commands.test.ts
@@ -0,0 +1,210 @@
+import type { RenderInput } from "claude-code";
+import { describe, expect, test } from "claude-code/testing";
+
+import { BRIDGE, GLOW } from "../hooks/palette";
+import {
+  AT,
+  BAND,
+  elementsOf,
+  EVENT,
+  PLUGIN,
+  SESSION,
+  SUMMARY,
+  textOf,
+  typed,
+  world,
+} from "./fixtures";
+
+const PAST = {
+  ...SUMMARY,
+  slug: "2026-06-26-all-things-effect",
+  name: "Effect San Francisco 🇺🇸",
+  status: "past",
+  startsAt: "2026-07-01T00:30:00.000Z",
+  endsAt: "2026-07-01T03:30:00.000Z",
+  venue: {
+    name: "CodeRabbit",
+    address:
+      "CodeRabbit, 201 Spear St 12th floor, San Francisco, CA 94105, USA",
+  },
+  recordingUrl: "https://www.youtube.com/watch?v=effect",
+};
+
+const site = {
+  upcoming: [SUMMARY],
+  events: { [SUMMARY.slug]: EVENT, [PAST.slug]: PAST },
+};
+
+/** The /at output row, as Claude Code hands it to the mod to draw. */
+function atRow(
+  args: string,
+  text: string,
+): RenderInput<"CommandOutput", "terminal"> & { plugin: string } {
+  return {
+    plugin: PLUGIN,
+    component: "CommandOutput",
+    surface: "terminal",
+    requestId: "msg-1",
+    props: { command: "at", args, text, isErrored: false },
+  };
+}
+
+describe("/at and /imin", () => {
+  test("both register at the session's start, to run mid-turn", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    expect(w.registered).toEqual(["at", "imin"]);
+  });
+
+  test("a name that's taken costs only that command", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming, taken: ["at"] });
+    await $.session.start(SESSION);
+    expect(w.registered).toEqual(["imin"]);
+  });
+
+  test("/at prints the next evening's card, with who's on stage", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("at"));
+    expect(answer.text).toBe(
+      [
+        "allthings/agent-setups_",
+        "thu oct 15 · 5:30–8:30pm · FiDi · hosted at Sentry",
+        "45 Fremont St",
+        "· My agent setup, file by file — Ada Lovelace",
+        `I'm in → ${SUMMARY.rsvpUrl}`,
+        SUMMARY.url,
+      ].join("\n"),
+    );
+    expect(w.requests.map((request) => request.tool)).toEqual([
+      "list_events",
+      "get_event",
+    ]);
+  });
+
+  test("/at draws its row as a card: the slash in the theme's color, and links", async ($, on) => {
+    world(on, { site, now: AT.upcoming, theme: "light" });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("at"));
+    for (const surface of ["terminal", "desktop"] as const) {
+      const ui = await $.ui.mount({ ...atRow("", answer.text ?? ""), surface });
+      const card = await ui.find({ key: "card" });
+      expect(textOf(card)).toContain("allthings/agent-setups_");
+      const slash = elementsOf(card).find((element) => textOf(element) === "/");
+      expect(slash?.props).toMatchObject({ color: BRIDGE });
+      const links = elementsOf(card).filter(
+        (element) => element.type === "Link",
+      );
+      expect(links.map((link) => link.props)).toEqual([
+        { href: SUMMARY.rsvpUrl, label: "lu.ma/event/evt-agentsetups" },
+        {
+          href: SUMMARY.url,
+          label: "allthings.dev/2026-10-15-all-things-agent-setups",
+        },
+      ]);
+      await ui.unmount();
+    }
+  });
+
+  test("/at <slug> shows any evening; a past one loses its cursor and links its recording", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("at", PAST.slug));
+    expect(answer.text).toBe(
+      [
+        "allthings/effect",
+        "tue jun 30 · 5:30–8:30pm · East Cut · hosted at CodeRabbit",
+        "201 Spear St 12th floor",
+        `recording → ${PAST.recordingUrl}`,
+        PAST.url,
+      ].join("\n"),
+    );
+    expect(w.requests.map((request) => request.tool)).toEqual(["get_event"]);
+    const ui = await $.ui.mount(atRow(PAST.slug, answer.text ?? ""));
+    expect(textOf(await ui.find({ key: "card" }))).toStartWith(
+      "allthings/effect",
+    );
+  });
+
+  test("/at <slug> for no evening says so", async ($, on) => {
+    world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("at", "nope"));
+    expect(answer.text).toBe("no evening at nope. /at shows the next one.");
+  });
+
+  test("two /at runs at once share one list_events request", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming });
+    await $.session.start({ ...SESSION, isInteractive: false });
+    const [first, second] = await Promise.all([
+      $.command.run(typed("at")),
+      $.command.run(typed("at")),
+    ]);
+    expect(first.text).toBe(second.text);
+    expect(
+      w.requests.filter((request) => request.tool === "list_events"),
+    ).toHaveLength(1);
+  });
+
+  test("/at with nothing ahead points at the site", async ($, on) => {
+    world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("at"));
+    expect(answer.text).toBe(
+      "no evening on the calendar right now. https://allthings.dev has what's next.",
+    );
+  });
+
+  test("/at offline says it couldn't reach the site", async ($, on) => {
+    world(on, { site: { ...site, isDown: true }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("at"));
+    expect(answer.text).toBe(
+      "couldn't reach allthings.dev just now. try again in a minute.",
+    );
+  });
+
+  test("a row the mod drew no card for is Claude Code's", async ($, on) => {
+    world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const ui = await $.ui.mount(atRow("never-ran", "text"));
+    expect(await ui.find({ text: "drawn by Claude Code" })).toBeDefined();
+  });
+
+  test("/imin opens the next evening's Luma page, and the band signs off", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("imin"));
+    expect(w.opened).toEqual([["open", SUMMARY.rsvpUrl]]);
+    expect(answer.text).toBe(
+      "see you at/agent-setups · opened lu.ma/event/evt-agentsetups",
+    );
+    const ui = await $.ui.mount({ ...BAND, surface: "terminal" });
+    const band = await ui.find({ key: "band" });
+    expect(textOf(band)).toEndWith("see you at/agent-setups");
+    const slash = elementsOf(band)
+      .filter((element) => textOf(element) === "/")
+      .map((element) => element.props.color);
+    expect(slash).toEqual([GLOW, GLOW]);
+  });
+
+  test("/imin where no browser opens gives the link instead", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming, opener: "none" });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("imin"));
+    expect(answer.text).toBe(
+      `see you at/agent-setups · say you're in at ${SUMMARY.rsvpUrl}`,
+    );
+    expect(w.toasts).toEqual([`I'm in → ${SUMMARY.rsvpUrl}`]);
+  });
+
+  test("/imin with nothing ahead says so", async ($, on) => {
+    const w = world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const answer = await $.command.run(typed("imin"));
+    expect(answer.text).toBe(
+      "no evening on the calendar right now. https://allthings.dev has what's next.",
+    );
+    expect(w.opened).toEqual([]);
+  });
+});
diff --git a/plugins/allthings/tests/fixtures.ts b/plugins/allthings/tests/fixtures.ts
new file mode 100644
index 00000000..2de6ed6b
--- /dev/null
+++ b/plugins/allthings/tests/fixtures.ts
@@ -0,0 +1,327 @@
+/**
+ * The world the mod's tests stand it in: a session in /work, the plugin's
+ * MCP config, and the site's answers as recorded fixtures. No test reaches
+ * the network: `http.fetch` is always one of these stubs.
+ */
+
+import type {
+  HttpResponse,
+  On,
+  RenderInput,
+  SessionStartInput,
+} from "claude-code";
+import { mock } from "claude-code/testing";
+
+export const PLUGIN = "allthings";
+
+export const SESSION: SessionStartInput = {
+  surface: "terminal",
+  isInteractive: true,
+  cwd: "/work",
+};
+
+/** The plugin's mcp.json. */
+export const MCP_JSON = JSON.stringify({
+  $schema: "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  mcpServers: {
+    allthings: { type: "streamable-http", url: "https://allthings.dev/mcp" },
+  },
+});
+
+/** An evening as list_events (an EventSummary) returns it. */
+export const SUMMARY = {
+  slug: "2026-10-15-all-things-agent-setups",
+  name: "All Things Agent Setups",
+  tagline: "See Luma for event details and registration.",
+  url: "https://allthings.dev/2026-10-15-all-things-agent-setups",
+  status: "upcoming",
+  // 5:30–8:30pm PDT on Thursday, October 15.
+  startsAt: "2026-10-16T00:30:00.000Z",
+  endsAt: "2026-10-16T03:30:00.000Z",
+  timeZone: "America/Los_Angeles",
+  venue: {
+    name: "Sentry",
+    address: "Sentry, 45 Fremont St, San Francisco, CA 94105, USA",
+  },
+  rsvpUrl: "https://lu.ma/event/evt-agentsetups",
+  recordingUrl: null,
+  isHackathon: false,
+} as const;
+
+/** The same evening as get_event returns it. */
+export const EVENT = {
+  ...SUMMARY,
+  talks: [
+    {
+      title: "My agent setup, file by file",
+      description: "Plain text.",
+      speakers: [
+        {
+          name: "Ada Lovelace",
+          title: null,
+          bio: null,
+          links: { x: null, bluesky: null, linkedin: null },
+        },
+      ],
+    },
+  ],
+  hosts: [{ name: "Sentry", about: "Application monitoring." }],
+} as const;
+
+/** Instants around the evening, as milliseconds. */
+export const AT = {
+  /** Tuesday, October 13, noon in San Francisco. */
+  upcoming: Date.parse("2026-10-13T19:00:00.000Z"),
+  /** Thursday, October 15, 1pm: the day of. */
+  today: Date.parse("2026-10-15T20:00:00.000Z"),
+  /** 6pm, half an hour in. */
+  live: Date.parse("2026-10-16T01:00:00.000Z"),
+  /** 9pm, after it ended. */
+  past: Date.parse("2026-10-16T04:00:00.000Z"),
+} as const;
+
+/** A tool call's answer as the site's MCP server streams it. */
+export function sse(result: unknown): HttpResponse {
+  return {
+    status: 200,
+    ok: true,
+    headers: { "content-type": "text/event-stream" },
+    text: `event: message\ndata: ${JSON.stringify({ result, jsonrpc: "2.0", id: 1 })}\n\n`,
+  };
+}
+
+export const structured = (value: unknown) => ({
+  content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+  structuredContent: value,
+});
+
+export const NOT_FOUND = {
+  isError: true,
+  content: [{ type: "text", text: 'No published event with slug "nope".' }],
+};
+
+/** What the site answers: the evenings ahead, and get_event's by slug. */
+export type Site = {
+  upcoming: readonly unknown[];
+  events?: Readonly<Record<string, unknown>>;
+  /** True: every request fails, as offline. */
+  isDown?: boolean;
+};
+
+/**
+ * Stands the mod in a session: settings, environment, store, clock, the
+ * plugin's files and the site. Returns what the mod asked of the world.
+ */
+export function world(
+  on: On,
+  options: {
+    site: Site;
+    now: number;
+    theme?: string;
+    reduceMotion?: boolean;
+    stored?: Record<string, unknown>;
+    mcpJson?: string;
+    surface?: "terminal" | "desktop";
+    /** Whether the machine has a browser opener: macOS open, or none at all. */
+    opener?: "mac" | "none";
+    /** True: the store can be neither read nor written, as in a locked-down home. */
+    isStoreDown?: boolean;
+    /** Command names something else already took. */
+    taken?: readonly string[];
+  },
+) {
+  const requests: { url: string; tool: string; args: unknown }[] = [];
+  const opened: string[][] = [];
+  const toasts: string[] = [];
+  const registered: string[] = [];
+  const clock = mock.clock(on, { now: options.now });
+  // The store, kept where the test can read what the mod saved.
+  const stored = new Map<string, unknown>(Object.entries(options.stored ?? {}));
+  const storeDown = { deny: "EPERM: operation not permitted" } as const;
+  on("store.get", ($, e) =>
+    options.isStoreDown === true ? storeDown : { value: stored.get(e.key) },
+  );
+  on("store.set", ($, e) => {
+    if (options.isStoreDown === true) return storeDown;
+    stored.set(e.key, e.value);
+    return { value: undefined };
+  });
+  on("store.delete", ($, e) => {
+    stored.delete(e.key);
+    return { value: undefined };
+  });
+  on("store.keys", () => ({ value: [...stored.keys()] }));
+  mock.env(on, {});
+  on("session.start", () => ({ cwd: SESSION.cwd }));
+  on("classic.SessionStart", () => ({}));
+  on("command.register", ($, e) => {
+    if (options.taken?.includes(e.name) === true) {
+      return { deny: `"/${e.name}" refused: it is taken` };
+    }
+    registered.push(e.name);
+    return { value: { command: e.name } };
+  });
+  on("config.list", () => ({
+    value: [
+      {
+        key: "theme",
+        label: "Theme",
+        kind: "choice",
+        value: options.theme ?? "dark",
+        provider: { plugin: "engine", tier: "core" },
+        isLocked: false,
+      },
+      {
+        key: "reduceMotion",
+        label: "Reduce motion",
+        kind: "boolean",
+        value: options.reduceMotion ?? false,
+        provider: { plugin: "engine", tier: "core" },
+        isLocked: false,
+      },
+    ],
+  }));
+  on("fs.read", ($, e) => {
+    if (e.path.endsWith("/mcp.json") && !e.path.endsWith("/.mcp.json")) {
+      return { value: options.mcpJson ?? MCP_JSON };
+    }
+    return { deny: `ENOENT: ${e.path}` };
+  });
+  on("http.fetch", ($, e) => {
+    const body = JSON.parse(e.init?.body ?? "{}") as {
+      params?: { name?: string; arguments?: { slug?: string } };
+    };
+    const tool = body.params?.name ?? "";
+    requests.push({ url: e.url, tool, args: body.params?.arguments });
+    if (options.site.isDown === true) return { deny: "getaddrinfo ENOTFOUND" };
+    if (tool === "list_events")
+      return { value: sse(structured({ events: options.site.upcoming })) };
+    if (tool === "get_event") {
+      const event = options.site.events?.[body.params?.arguments?.slug ?? ""];
+      return {
+        value: sse(event === undefined ? NOT_FOUND : structured(event)),
+      };
+    }
+    return { value: { status: 404, ok: false, headers: {}, text: "" } };
+  });
+  on("process.run", ($, e) => {
+    if (options.opener === "none")
+      return { deny: `spawn ${e.argv[0] ?? ""} ENOENT` };
+    opened.push([...e.argv]);
+    const exitCode = e.argv[0] === "open" ? 0 : 1;
+    return {
+      value: {
+        exitCode,
+        stdout: "",
+        stderr: "",
+        isStdoutTruncated: false,
+        isStderrTruncated: false,
+      },
+    };
+  });
+  on("ui.toast", ($, e) => {
+    toasts.push(e.text);
+    return { value: undefined };
+  });
+  // What Claude Code draws where the mod passes: a site left as it was.
+  on("ui.render", () => ({
+    type: "Text",
+    props: {},
+    children: ["drawn by Claude Code"],
+  }));
+  return { requests, opened, toasts, registered, clock, stored };
+}
+
+/** The band above the prompt, 120 columns wide. */
+export const BAND: Omit<RenderInput<"AbovePrompt">, "surface"> & {
+  plugin: string;
+} = {
+  plugin: PLUGIN,
+  component: "AbovePrompt",
+  requestId: "above-prompt",
+  viewport: { columns: 120, rows: 40 },
+  props: {
+    hasSurvey: false,
+    isWorking: false,
+    maxRows: 10,
+    bodyColumns: 120,
+    scroll: { offset: 0, bodyRows: 9 },
+    view: {},
+  },
+};
+
+/** A tool call's row, for a tool and its input. */
+export function toolRow(
+  tool: string,
+  input: unknown,
+  state: {
+    isRunning?: boolean;
+    isErrored?: boolean;
+    isInterrupted?: boolean;
+  } = {},
+  surface: "terminal" | "desktop" = "terminal",
+) {
+  return {
+    plugin: PLUGIN,
+    surface,
+    component: "ToolUse",
+    requestId: "toolu_1",
+    viewport: { columns: 120, rows: 40 },
+    props: {
+      tool_use_id: "toolu_1",
+      tool,
+      input,
+      isRunning: state.isRunning ?? false,
+      isErrored: state.isErrored ?? false,
+      isInterrupted: state.isInterrupted ?? false,
+    },
+  } as const;
+}
+
+/** A drawing's text as it reads: strings, labels and sources, in order. */
+export function textOf(tree: unknown): string {
+  if (typeof tree === "string" || typeof tree === "number") return String(tree);
+  if (Array.isArray(tree)) return tree.map(textOf).join("");
+  if (typeof tree !== "object" || tree === null) return "";
+  const props: unknown = Reflect.get(tree, "props");
+  const label =
+    typeof props === "object" && props !== null
+      ? Reflect.get(props, "label")
+      : undefined;
+  return `${typeof label === "string" ? label : ""}${textOf(Reflect.get(tree, "children") ?? [])}`;
+}
+
+/** One element of a drawing, as plain data. */
+export type Drawn = {
+  type: string;
+  props: Record<string, unknown>;
+  children: unknown[];
+};
+
+/** Every element of a drawing, depth first. */
+export function elementsOf(tree: unknown): Drawn[] {
+  if (Array.isArray(tree)) return tree.flatMap(elementsOf);
+  if (typeof tree !== "object" || tree === null) return [];
+  const type: unknown = Reflect.get(tree, "type");
+  const props: unknown = Reflect.get(tree, "props");
+  const children: unknown = Reflect.get(tree, "children");
+  const element: Drawn = {
+    type: typeof type === "string" ? type : "",
+    props:
+      typeof props === "object" && props !== null
+        ? (props as Record<string, unknown>)
+        : {},
+    children: Array.isArray(children) ? children : [],
+  };
+  return [element, ...elementsOf(element.children)];
+}
+
+/** A slash command as the person runs it from the prompt. */
+export function typed(command: string, args = "") {
+  return {
+    command,
+    args,
+    origin: { kind: "composer" },
+    presentation: { isFullscreen: false, columns: 120 },
+  } as const;
+}
diff --git a/plugins/allthings/tests/rows.test.ts b/plugins/allthings/tests/rows.test.ts
new file mode 100644
index 00000000..6625cb33
--- /dev/null
+++ b/plugins/allthings/tests/rows.test.ts
@@ -0,0 +1,204 @@
+import { describe, expect, test } from "claude-code/testing";
+
+import { BRIDGE, GLOW } from "../hooks/palette";
+import { AT, elementsOf, SESSION, textOf, toolRow, world } from "./fixtures";
+
+const site = { upcoming: [] };
+
+/** Each tool's call, and the row the slash grammar draws for it. */
+const ROWS: readonly (readonly [tool: string, input: unknown, row: string])[] =
+  [
+    ["Read", { file_path: "/work/src/app.ts" }, "read/src/app.ts"],
+    [
+      "Read",
+      { file_path: "/work/src/app.ts", offset: 10, limit: 50 },
+      "read/src/app.ts (lines 10–59)",
+    ],
+    [
+      "Edit",
+      { file_path: "/work/home.tsx", old_string: "a", new_string: "b" },
+      "edit/home.tsx",
+    ],
+    [
+      "Edit",
+      {
+        file_path: "/work/home.tsx",
+        old_string: "a",
+        new_string: "b",
+        replace_all: true,
+      },
+      "edit/home.tsx (every match)",
+    ],
+    [
+      "MultiEdit",
+      { file_path: "/work/home.tsx", edits: [{}, {}] },
+      "edit/home.tsx (2 edits)",
+    ],
+    ["Write", { file_path: "/work/notes.md", content: "hi" }, "write/notes.md"],
+    [
+      "NotebookEdit",
+      { notebook_path: "/work/a.ipynb", cell_id: "c1", new_source: "x" },
+      "edit/a.ipynb (cell c1)",
+    ],
+    ["Bash", { command: "bun test" }, "bash/bun test"],
+    [
+      "Bash",
+      { command: "bun run dev", run_in_background: true },
+      "bash/bun run dev (in the background)",
+    ],
+    ["Grep", { pattern: "curation" }, 'search/"curation"'],
+    [
+      "Grep",
+      { pattern: "curation", path: "/work/src", glob: "*.ts" },
+      'search/"curation" (in src · *.ts)',
+    ],
+    ["Glob", { pattern: "**/*.tsx" }, "find/**/*.tsx"],
+    [
+      "WebFetch",
+      { url: "https://allthings.dev/", prompt: "what's next" },
+      "fetch/allthings.dev",
+    ],
+    [
+      "WebFetch",
+      { url: "https://www.allthings.dev/events?when=all" },
+      "fetch/allthings.dev/events?when=all",
+    ],
+    ["WebSearch", { query: "sf meetups" }, 'search/"sf meetups" (the web)'],
+    [
+      "Agent",
+      {
+        description: "Find the venue table",
+        prompt: "…",
+        subagent_type: "Explore",
+      },
+      "agent/Find the venue table (Explore)",
+    ],
+    ["Skill", { skill: "find-evenings" }, "skill/find-evenings"],
+    ["TodoWrite", { todos: [{}, {}, {}] }, "todo/3 items"],
+    [
+      "mcp__plugin_allthings_allthings__list_events",
+      { when: "upcoming", limit: 1 },
+      "allthings/list_events (when: upcoming, limit: 1)",
+    ],
+    ["mcp__github__get_issue", { number: 7 }, "github/get_issue (number: 7)"],
+    ["ExitPlanMode", { plan: "ship it" }, "exit-plan-mode/plan: ship it"],
+  ];
+
+describe("tool rows in the slash grammar", () => {
+  for (const [tool, input, row] of ROWS) {
+    test(`${tool} draws ${row}`, async ($, on) => {
+      world(on, { site, now: AT.upcoming });
+      await $.session.start(SESSION);
+      const ui = await $.ui.mount(toolRow(tool, input));
+      const drawn = await ui.find({ key: "row-toolu_1" });
+      expect(textOf(drawn).replace("⏺ ", "")).toBe(row);
+    });
+  }
+
+  test("the verb is lowercase and the slash is Glow on a dark theme", async ($, on) => {
+    world(on, { site, now: AT.upcoming, theme: "dark" });
+    await $.session.start(SESSION);
+    const ui = await $.ui.mount(
+      toolRow("Read", { file_path: "/work/src/app.ts" }),
+    );
+    const elements = elementsOf(await ui.find({ key: "row-toolu_1" }));
+    const verb = elements.find((element) => textOf(element) === "read");
+    const slash = elements.find((element) => textOf(element) === "/");
+    expect(verb?.props).toMatchObject({ bold: true });
+    expect(slash?.props).toMatchObject({ color: GLOW });
+  });
+
+  test("the slash is Bridge on a light theme, and on allthings paper", async ($, on) => {
+    world(on, { site, now: AT.upcoming, theme: "custom:allthings-paper" });
+    await $.session.start(SESSION);
+    const ui = await $.ui.mount(toolRow("Bash", { command: "ls" }));
+    const slash = elementsOf(await ui.find({ key: "row-toolu_1" })).find(
+      (element) => textOf(element) === "/",
+    );
+    expect(slash?.props).toMatchObject({ color: BRIDGE });
+  });
+
+  test("the status dot keeps Claude Code's states", async ($, on) => {
+    world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const dotOf = async (state: Parameters<typeof toolRow>[2]) => {
+      const ui = await $.ui.mount(toolRow("Bash", { command: "ls" }, state));
+      const dot = elementsOf(await ui.find({ key: "row-toolu_1" })).find(
+        (element) => textOf(element) === "⏺ ",
+      );
+      await ui.unmount();
+      return dot?.props.color;
+    };
+    expect(await dotOf({ isRunning: true })).toBe("inactive");
+    expect(await dotOf({})).toBe("success");
+    expect(await dotOf({ isErrored: true })).toBe("error");
+    expect(await dotOf({ isInterrupted: true })).toBe("error");
+  });
+
+  test("an interrupted call still says so", async ($, on) => {
+    world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const ui = await $.ui.mount(
+      toolRow("Bash", { command: "sleep 60" }, { isInterrupted: true }),
+    );
+    expect(textOf(await ui.find({ key: "row-toolu_1" }))).toContain(
+      "⎿  Interrupted",
+    );
+  });
+
+  test("a running call's dot blinks with the cursor", async ($, on) => {
+    const w = world(on, { site, now: AT.upcoming });
+    on("turn.start", (_engine, e) => ({ turnId: e.turnId }));
+    await $.session.start(SESSION);
+    await $.turn.start({ text: "go", turnId: "t1" });
+    const dimOf = async () => {
+      const ui = await $.ui.mount(
+        toolRow("Bash", { command: "bun test" }, { isRunning: true }),
+      );
+      const dot = elementsOf(await ui.find({ key: "row-toolu_1" })).find(
+        (element) => textOf(element) === "⏺ ",
+      );
+      await ui.unmount();
+      return dot?.props.dimColor;
+    };
+    expect(await dimOf()).toBe(false);
+    await w.clock.advance(500);
+    expect(await dimOf()).toBe(true);
+  });
+
+  test("the desktop's rows stay its own, with their expand and collapse", async ($, on) => {
+    world(on, { site, now: AT.upcoming, surface: "desktop" });
+    await $.session.start({ ...SESSION, surface: "desktop" });
+    const ui = await $.ui.mount(
+      toolRow("Read", { file_path: "/work/src/app.ts" }, {}, "desktop"),
+    );
+    expect(await ui.find({ text: "drawn by Claude Code" })).toBeDefined();
+    expect(await ui.find({ key: "row-toolu_1" })).toBeUndefined();
+  });
+
+  test("a row in an expanded group, which carries its output, stays Claude Code's", async ($, on) => {
+    world(on, { site, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await $.ui.render({
+      component: "ToolGroup",
+      surface: "terminal",
+      requestId: "group-1",
+      props: {
+        calls: [
+          {
+            tool_use_id: "toolu_1",
+            tool: "Read",
+            input: { file_path: "/work/a.ts" },
+            isRunning: false,
+            isErrored: false,
+            isInterrupted: false,
+          },
+        ],
+        isActive: false,
+        isExpanded: true,
+      },
+    });
+    const ui = await $.ui.mount(toolRow("Read", { file_path: "/work/a.ts" }));
+    expect(await ui.find({ text: "drawn by Claude Code" })).toBeDefined();
+  });
+});
diff --git a/plugins/allthings/tests/spinner.test.ts b/plugins/allthings/tests/spinner.test.ts
new file mode 100644
index 00000000..cf54cfc7
--- /dev/null
+++ b/plugins/allthings/tests/spinner.test.ts
@@ -0,0 +1,131 @@
+import type { On, RenderInput } from "claude-code";
+import { describe, expect, test } from "claude-code/testing";
+import type { Engine } from "claude-code/testing";
+
+import { phraseAt, seedOf } from "../hooks/city";
+import { AT, SESSION, SUMMARY, textOf, world } from "./fixtures";
+
+const SPINNER: RenderInput<"Spinner", "terminal"> = {
+  component: "Spinner",
+  surface: "terminal",
+  requestId: "main",
+  props: { word: "Sauteing", message: null, suffix: "…", mode: "thinking" },
+};
+
+/** Claude Code's spinner, as the props reach it: the word or message, then the suffix. */
+function echoSpinner(on: On) {
+  on("ui.render", { component: "Spinner" }, ($, e) => ({
+    type: "Text",
+    props: {},
+    children: [`${e.props.message ?? e.props.word}${e.props.suffix}`],
+  }));
+  on("turn.start", ($, e) => ({ turnId: e.turnId }));
+  on("turn.complete", () => ({ text: "" }));
+}
+
+async function frame(
+  $: Engine,
+  input: RenderInput<"Spinner"> = SPINNER,
+): Promise<string> {
+  return textOf(await $.ui.render(input));
+}
+
+describe("the spinner as the wordmark, wandering the city", () => {
+  test("the first lines walk SoMa, the Mission, Dogpatch, the Tenderloin and FiDi", () => {
+    expect([0, 1, 2, 3, 4].map(phraseAt)).toEqual([
+      "shipping in SoMa",
+      "pairing in the Mission",
+      "debugging in Dogpatch",
+      "refactoring in the Tenderloin",
+      "deploying from FiDi",
+    ]);
+  });
+
+  test("a turn's spinner reads allthings/_ and a working verb somewhere in the city", async ($, on) => {
+    echoSpinner(on);
+    world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await $.turn.start({ text: "go", turnId: "t1" });
+    expect(await frame($)).toBe(`allthings/_ ${phraseAt(seedOf("t1"))}…`);
+  });
+
+  test("the cursor blinks every half second while the turn runs", async ($, on) => {
+    echoSpinner(on);
+    const w = world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await $.turn.start({ text: "go", turnId: "t1" });
+    const phrase = phraseAt(seedOf("t1"));
+    expect(await frame($)).toBe(`allthings/_ ${phrase}…`);
+    await w.clock.advance(500);
+    expect(await frame($)).toBe(`allthings/  ${phrase}…`);
+    await w.clock.advance(500);
+    expect(await frame($)).toBe(`allthings/_ ${phrase}…`);
+  });
+
+  test("the line moves to the next neighborhood every six seconds", async ($, on) => {
+    echoSpinner(on);
+    const w = world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await $.turn.start({ text: "go", turnId: "t1" });
+    await w.clock.advance(6_000);
+    expect(await frame($)).toBe(`allthings/_ ${phraseAt(seedOf("t1") + 1)}…`);
+  });
+
+  test("nothing blinks once the turn is over and no evening is ahead", async ($, on) => {
+    echoSpinner(on);
+    const w = world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    await $.turn.start({ text: "go", turnId: "t1" });
+    await $.turn.complete({
+      turnId: "t1",
+      answer: "done",
+      durationMs: 1,
+      isAborted: false,
+      reason: "answer",
+    });
+    const before = await frame($);
+    await w.clock.advance(500);
+    expect(await frame($)).toBe(before);
+  });
+
+  test("with reduce motion on, the cursor stays solid", async ($, on) => {
+    echoSpinner(on);
+    const w = world(on, {
+      site: { upcoming: [SUMMARY] },
+      now: AT.upcoming,
+      reduceMotion: true,
+    });
+    await $.session.start(SESSION);
+    await $.turn.start({ text: "go", turnId: "t1" });
+    await w.clock.advance(500);
+    expect(await frame($)).toStartWith("allthings/_ ");
+  });
+
+  test("a state's message keeps its words, after the wordmark", async ($, on) => {
+    echoSpinner(on);
+    world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start(SESSION);
+    const drawn = await frame($, {
+      ...SPINNER,
+      props: { ...SPINNER.props, message: "Compacting conversation" },
+    });
+    expect(drawn).toBe("allthings/_ · Compacting conversation…");
+  });
+
+  test("the desktop's word says what the step does, so it stays", async ($, on) => {
+    echoSpinner(on);
+    world(on, { site: { upcoming: [] }, now: AT.upcoming });
+    await $.session.start({ ...SESSION, surface: "desktop" });
+    const desktop = (word: string): RenderInput<"Spinner", "desktop"> => ({
+      ...SPINNER,
+      surface: "desktop",
+      props: { ...SPINNER.props, word },
+    });
+    expect(await frame($, desktop("Creating notes.md"))).toBe(
+      "allthings/_ · Creating notes.md…",
+    );
+    expect(await frame($, desktop("Working"))).toBe(
+      `allthings/_ ${phraseAt(0)}…`,
+    );
+  });
+});
diff --git a/plugins/allthings/tests/units.test.ts b/plugins/allthings/tests/units.test.ts
new file mode 100644
index 00000000..2926b779
--- /dev/null
+++ b/plugins/allthings/tests/units.test.ts
@@ -0,0 +1,167 @@
+import { describe, expect, test } from "claude-code/testing";
+
+import { NEIGHBORHOODS, neighborhoodOf, phraseAt } from "../hooks/city";
+import {
+  endpointOf,
+  eveningOf,
+  phaseOf,
+  toolAnswerOf,
+  topicOf,
+} from "../hooks/evenings";
+import { BRIDGE, GLOW, slashColorOf } from "../hooks/palette";
+import { relative } from "../hooks/rows";
+import { clockOf, dayOf, pacificOffset, spanOf, untilOf } from "../hooks/time";
+import { AT, SUMMARY } from "./fixtures";
+
+describe("the city", () => {
+  test("the spinner walks at least 20 real neighborhoods, each once", () => {
+    const names = NEIGHBORHOODS.map((hood) => hood.name);
+    expect(names.length).toBeGreaterThanOrEqual(20);
+    expect(new Set(names).size).toBe(names.length);
+    expect(names).toContain("FiDi");
+    expect(names).not.toContain("Financial District");
+  });
+
+  test("every line is a lowercase verb somewhere in the city", () => {
+    for (let n = 0; n < 200; n += 1)
+      expect(phraseAt(n)).toMatch(/^[a-z]+ (in|from) (the )?[A-Z]/);
+  });
+
+  test("venues the community knows are named as locals name them", () => {
+    expect(
+      neighborhoodOf(
+        "CodeRabbit, 201 Spear St 12th floor, San Francisco, CA 94105, USA",
+      ),
+    ).toBe("East Cut");
+    expect(
+      neighborhoodOf("Sentry, 45 Fremont St, San Francisco, CA 94105, USA"),
+    ).toBe("FiDi");
+    expect(neighborhoodOf("444 De Haro Street, San Francisco, CA 94107")).toBe(
+      "Potrero Hill",
+    );
+    expect(neighborhoodOf("Pier 70, San Francisco, CA 94107")).toBe("Dogpatch");
+  });
+
+  test("a new venue's neighborhood comes from its ZIP code, and nothing is guessed outside the city", () => {
+    expect(neighborhoodOf("1 Valencia St, San Francisco, CA 94110")).toBe(
+      "Mission",
+    );
+    expect(neighborhoodOf("1 Main St, Oakland, CA 94607")).toBeNull();
+    expect(neighborhoodOf(null)).toBeNull();
+    // A known street address matches whole, never inside a longer number.
+    expect(neighborhoodOf("145 Fremont St, San Francisco, CA 94105")).toBe(
+      "East Cut",
+    );
+  });
+});
+
+describe("evenings", () => {
+  test("the topic is what follows all things, lowercase", () => {
+    expect(topicOf("All Things Agent Setups")).toBe("agent-setups");
+    expect(topicOf("allthings/effect")).toBe("effect");
+    expect(topicOf("all things/react native")).toBe("react-native");
+    expect(topicOf("Effect San Francisco 🇺🇸")).toBe("effect");
+  });
+
+  test("the server's URL is read from the plugin's MCP config", () => {
+    expect(
+      endpointOf(
+        '{"mcpServers":{"allthings":{"type":"streamable-http","url":"https://allthings.dev/mcp"}}}',
+      ),
+    ).toBe("https://allthings.dev/mcp");
+    expect(
+      endpointOf(
+        '{"allthings":{"type":"http","url":"https://allthings.dev/mcp"}}',
+      ),
+    ).toBe("https://allthings.dev/mcp");
+    expect(endpointOf('{"mcpServers":{"x":{"command":"node"}}}')).toBeNull();
+    expect(endpointOf("not json")).toBeNull();
+  });
+
+  test("answers are read from JSON and from an event stream", () => {
+    const rpc = {
+      jsonrpc: "2.0",
+      id: 1,
+      result: { content: [], structuredContent: { events: [] } },
+    };
+    expect(toolAnswerOf(JSON.stringify(rpc), "application/json")).toEqual({
+      isError: false,
+      structured: { events: [] },
+    });
+    expect(
+      toolAnswerOf(
+        `event: message\ndata: ${JSON.stringify(rpc)}\n\n`,
+        "text/event-stream",
+      ),
+    ).toEqual({
+      isError: false,
+      structured: { events: [] },
+    });
+    expect(() =>
+      toolAnswerOf(
+        '{"jsonrpc":"2.0","id":1,"error":{"message":"bad"}}',
+        "application/json",
+      ),
+    ).toThrow("bad");
+  });
+
+  test("an evening's phase follows the clock in San Francisco", () => {
+    const evening = eveningOf(SUMMARY);
+    expect(evening).not.toBeNull();
+    if (evening === null) return;
+    expect(phaseOf(evening, AT.upcoming)).toBe("upcoming");
+    expect(phaseOf(evening, AT.today)).toBe("today");
+    expect(phaseOf(evening, AT.live)).toBe("live");
+    expect(phaseOf(evening, AT.past)).toBe("past");
+  });
+});
+
+describe("San Francisco time", () => {
+  test("follows daylight saving time", () => {
+    expect(pacificOffset(Date.parse("2026-01-15T12:00:00Z"))).toBe(-8);
+    expect(pacificOffset(Date.parse("2026-07-15T12:00:00Z"))).toBe(-7);
+    // 2026: DST starts March 8 at 10:00 UTC and ends November 1 at 09:00 UTC.
+    expect(pacificOffset(Date.parse("2026-03-08T09:59:00Z"))).toBe(-8);
+    expect(pacificOffset(Date.parse("2026-03-08T10:00:00Z"))).toBe(-7);
+    expect(pacificOffset(Date.parse("2026-11-01T08:59:00Z"))).toBe(-7);
+    expect(pacificOffset(Date.parse("2026-11-01T09:00:00Z"))).toBe(-8);
+  });
+
+  test("reads dates, times and countdowns the way the site does", () => {
+    const starts = Date.parse(SUMMARY.startsAt);
+    expect(dayOf(starts)).toBe("thu oct 15");
+    expect(clockOf(starts)).toBe("5:30pm");
+    expect(clockOf(Date.parse("2026-10-16T01:00:00Z"))).toBe("6pm");
+    expect(spanOf(starts, Date.parse(SUMMARY.endsAt))).toBe("5:30–8:30pm");
+    expect(
+      spanOf(
+        Date.parse("2026-10-17T18:00:00Z"),
+        Date.parse("2026-10-17T21:00:00Z"),
+      ),
+    ).toBe("11am–2pm");
+    expect(untilOf(0, 134 * 60_000)).toBe("2h 14m");
+    expect(untilOf(0, 45 * 60_000)).toBe("45m");
+    expect(untilOf(0, 120 * 60_000)).toBe("2h");
+  });
+});
+
+describe("the slash's color", () => {
+  test("Bridge on light grounds, Glow on Night and dark ones", () => {
+    expect(slashColorOf("light", undefined)).toBe(BRIDGE);
+    expect(slashColorOf("light-daltonized", undefined)).toBe(BRIDGE);
+    expect(slashColorOf("custom:allthings-paper", undefined)).toBe(BRIDGE);
+    expect(slashColorOf("dark", undefined)).toBe(GLOW);
+    expect(slashColorOf("custom:allthings-night", undefined)).toBe(GLOW);
+    expect(slashColorOf("auto", "0;15")).toBe(BRIDGE);
+    expect(slashColorOf("auto", "15;0")).toBe(GLOW);
+    expect(slashColorOf("auto", undefined)).toBe(GLOW);
+  });
+});
+
+describe("paths", () => {
+  test("a path in the session's folder is drawn relative to it", () => {
+    expect(relative("/work/src/app.ts", "/work")).toBe("src/app.ts");
+    expect(relative("/elsewhere/a.ts", "/work")).toBe("/elsewhere/a.ts");
+    expect(relative("/work", "/work")).toBe(".");
+  });
+});
diff --git a/plugins/allthings/themes/allthings-night.json b/plugins/allthings/themes/allthings-night.json
new file mode 100644
index 00000000..ede4bcc0
--- /dev/null
+++ b/plugins/allthings/themes/allthings-night.json
@@ -0,0 +1,24 @@
+{
+  "name": "allthings night",
+  "base": "dark",
+  "overrides": {
+    "claude": "#FF6A3D",
+    "claudeShimmer": "#FF9B7A",
+    "text": "#F4F1EC",
+    "inactive": "#DACFFF",
+    "inactiveShimmer": "#E3DCF7",
+    "suggestion": "#DACFFF",
+    "permission": "#DACFFF",
+    "permissionShimmer": "#E3DCF7",
+    "remember": "#DACFFF",
+    "promptBorder": "#332E48",
+    "promptBorderShimmer": "#DACFFF",
+    "userMessageBackground": "#242033",
+    "userMessageBackgroundHover": "#332E48",
+    "bashMessageBackgroundColor": "#242033",
+    "memoryBackgroundColor": "#242033",
+    "selectionBg": "#332E48",
+    "briefLabelYou": "#DACFFF",
+    "briefLabelClaude": "#FF6A3D"
+  }
+}
diff --git a/plugins/allthings/themes/allthings-paper.json b/plugins/allthings/themes/allthings-paper.json
new file mode 100644
index 00000000..23675324
--- /dev/null
+++ b/plugins/allthings/themes/allthings-paper.json
@@ -0,0 +1,24 @@
+{
+  "name": "allthings paper",
+  "base": "light",
+  "overrides": {
+    "claude": "#C0362C",
+    "claudeShimmer": "#D9665D",
+    "text": "#141210",
+    "inactive": "#5E5A55",
+    "inactiveShimmer": "#8A857F",
+    "suggestion": "#5B34D6",
+    "permission": "#5B34D6",
+    "permissionShimmer": "#8466E0",
+    "remember": "#5B34D6",
+    "promptBorder": "#D2CCC3",
+    "promptBorderShimmer": "#C0362C",
+    "userMessageBackground": "#E6E2DC",
+    "userMessageBackgroundHover": "#D2CCC3",
+    "bashMessageBackgroundColor": "#E6E2DC",
+    "memoryBackgroundColor": "#E6E2DC",
+    "selectionBg": "#D2CCC3",
+    "briefLabelYou": "#5B34D6",
+    "briefLabelClaude": "#9A2B22"
+  }
+}
diff --git a/plugins/allthings/tsconfig.json b/plugins/allthings/tsconfig.json
new file mode 100644
index 00000000..8681ec01
--- /dev/null
+++ b/plugins/allthings/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "./.claude-plugin/types/tsconfig.json"
+}
diff --git a/plugins/allthings/types/index.d.ts b/plugins/allthings/types/index.d.ts
new file mode 100644
index 00000000..39b0d2e9
--- /dev/null
+++ b/plugins/allthings/types/index.d.ts
@@ -0,0 +1,69 @@
+/**
+ * The allthings mod's contract: the values it keeps in `$.state`, and the
+ * shapes they hold. The hooks module imports these types from here, so this
+ * file is the one place they are written.
+ */
+
+/** One talk of an evening, as `get_event` lists it. */
+export type EveningTalk = {
+  title: string;
+  speakers: readonly string[];
+};
+
+/**
+ * An evening as the mod draws it: the site's EventSummary (`list_events`),
+ * with the fields `get_event` adds when the mod asked for them, and the topic
+ * and neighborhood the mod derives.
+ */
+export type Evening = {
+  slug: string;
+  name: string;
+  /** The <topic> of allthings/<topic>: lowercase, from the evening's name. */
+  topic: string;
+  url: string;
+  status: "upcoming" | "live" | "past";
+  /** ISO 8601 UTC instants. */
+  startsAt: string;
+  endsAt: string;
+  venueName: string | null;
+  address: string | null;
+  /** The local name of the venue's neighborhood, when the mod knows it. */
+  neighborhood: string | null;
+  rsvpUrl: string | null;
+  recordingUrl: string | null;
+  isHackathon: boolean;
+  /** Hosting companies; empty until `get_event` has been asked. */
+  hosts: readonly string[];
+  /** Empty until `get_event` has been asked. */
+  talks: readonly EveningTalk[];
+};
+
+/** A card `/at` printed, keyed in `cards` by the arguments it ran with. */
+export type Card = {
+  evening: Evening;
+  /** When the card was made, in milliseconds since the epoch. */
+  at: number;
+};
+
+declare module "claude-code" {
+  interface PluginState {
+    allthings: {
+      /** The next evening, from list_events (upcoming, limit 1); null for none. */
+      next: Evening | null;
+      /** When `next` was last fetched, in milliseconds; 0 for never. */
+      fetchedAt: number;
+      /** The clock the band reads, moved every 30 seconds. */
+      now: number;
+      /** Moves every half second while something blinks: the cursor and the spinner. */
+      tick: number;
+      /** Slugs of the evenings the person pressed "I'm in" for. */
+      clicked: readonly string[];
+      /** The slash's color for the session's theme: Bridge on light, Glow on dark. */
+      slash: string;
+      /** The person's reduce-motion setting: the cursor stays solid. */
+      reduceMotion: boolean;
+      /** The cards `/at` printed, keyed by their arguments ("" for the next one). */
+      cards: Readonly<Record<string, Card>>;
+    };
+  }
+}