feat: add skeleton placeholders for loading posts

Reviewed-on: #4

.env.example

@@ -1,2 +1,14 @@
 TWITTER_RELAY_BASE_URL=http://127.0.0.1:6900
-BIRD_PROFILE_NAME=
+TWITTER_LITE_ORIGIN=https://your-host.your-tailnet.ts.net
+TWITTER_LITE_ALLOWED_LOGIN=your-tailscale-login
+TWITTER_LITE_DB_PATH=/absolute/path/to/twitter-lite/.data/workspace.sqlite
+# Required when connecting Mastodon; keep this runtime file outside Git.
+# TWITTER_LITE_CREDENTIAL_KEY_FILE=/absolute/path/to/credential-key
+TWITTER_LITE_MASTODON_ORIGINS=https://fedi.yutakobayashi.com
+# Optional Codex research. The AI SDK provider manages its local app-server.
+# TWITTER_LITE_CODEX_PATH=/absolute/path/to/codex
+# TWITTER_LITE_CODEX_MODEL=gpt-6-astra
+# TWITTER_LITE_REPORT_ROOT=/absolute/path/to/twitter-lite/.data/research
+
+# Optional initial owner setup code (32+ characters). Otherwise generated beside DB.
+# WORKSPACE_SETUP_TOKEN=

.gitignore

@@ -4,7 +4,10 @@
 .env*
 !.env.example
 .output/
+.tanstack/
 dist/
 node_modules/
 playwright-report/
 test-results/
+.data/
+*.setup-token

.hallmark/log.json

@@ -1,4 +1,44 @@
 [
+  {
+    "date": "2026-09-28",
+    "macrostructure": "daily home with natural-language composer and flexible plan",
+    "theme": "shadcn base-nova neutral",
+    "scope": "home",
+    "enrichment": "none",
+    "brief": "Greeting and large composer above time-free routines, tasks, contact actions and context; shared session state"
+  },
+  {
+    "date": "2026-09-28",
+    "macrostructure": "communication workbench and append-only journal",
+    "theme": "shadcn base-nova neutral",
+    "scope": "support",
+    "enrichment": "none",
+    "brief": "Compact execution support integrated with common sidebar, editable reply review and journal corrections"
+  },
+  {
+    "date": "2026-09-28",
+    "macrostructure": "sidebar-09 Inbox",
+    "theme": "shadcn base-nova neutral",
+    "scope": "inbox",
+    "enrichment": "none",
+    "brief": "Shared navigation with Twitter Lite, inferred-interest article list and reading pane; no manual interest settings"
+  },
+  {
+    "date": "2026-09-28",
+    "macrostructure": "sidebar-09 Workbench",
+    "theme": "shadcn base-nova neutral",
+    "scope": "app",
+    "enrichment": "none",
+    "brief": "Base UI icon rail and contextual sidebar with shadcn chat primitives and independent deck columns"
+  },
+  {
+    "date": "2026-09-24",
+    "macrostructure": "Workbench",
+    "theme": "custom",
+    "theme_axes": "dark navy / system sans / blue",
+    "enrichment": "none",
+    "brief": "Full-height TweetDeck-style research columns with compact sidebar and modal editors"
+  },
   {
     "date": "2026-07-26",
     "macrostructure": "Workbench",

.hallmark/preflight.json

@@ -1,9 +1,10 @@
 {
-  "date": "2026-07-26",
-  "font_stack": "Inter / Noto Sans JP / system sans declared in src/styles.css",
-  "palette": "CSS custom properties with muted teal hex values",
-  "motion": "motion-cut; no motion library",
-  "spacing": "no named scale",
+  "date": "2026-09-24",
+  "font_stack": "System sans; tokens.css",
+  "palette": "Dark navy and blue OKLCH tokens",
+  "motion": "motion-cut",
+  "spacing": "named token scale",
   "framework": "React 19 + TanStack Start + Vite 8",
-  "preserve": ["routes", "information architecture", "read-only behavior"]
+  "preserve": ["deck data model", "profile binding", "WebMCP contracts"],
+  "override": "User requested TweetDeck-like full UI redesign instead of Garden reader"
 }

.oxfmtrc.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "ignorePatterns": [".output/**", ".tanstack/**", "src/routeTree.gen.ts"]
+}

.oxlintrc.json

@@ -0,0 +1,206 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "categories": {
+    "correctness": "error"
+  },
+  "options": {
+    "typeAware": true,
+    "typeCheck": true
+  },
+  "plugins": [
+    "eslint",
+    "typescript",
+    "unicorn",
+    "oxc",
+    "import",
+    "node",
+    "promise",
+    "react",
+    "react-perf",
+    "jsx-a11y"
+  ],
+  "jsPlugins": ["@shadcn/lint"],
+  "rules": {
+    "no-console": "error",
+    "no-unused-vars": [
+      "error",
+      {
+        "argsIgnorePattern": "^_"
+      }
+    ],
+    "typescript/consistent-type-exports": "error",
+    "typescript/consistent-type-imports": [
+      "error",
+      {
+        "disallowTypeAnnotations": false
+      }
+    ],
+    "typescript/no-non-null-assertion": "error",
+    "typescript/no-explicit-any": "error",
+    "unicorn/no-useless-spread": "error",
+    "jsx-a11y/no-autofocus": "error",
+    "jsx-a11y/no-static-element-interactions": "error",
+    "jsx-a11y/prefer-tag-over-role": "off",
+    "react/exhaustive-deps": "error",
+    "react/purity": "error",
+    "react/rules-of-hooks": "error",
+    "react/set-state-in-effect": "error",
+    "shadcn/no-arbitrary-values": [
+      "error",
+      {
+        "allow": ["layout"]
+      }
+    ],
+    "shadcn/no-inline-styles": "error",
+    "shadcn/no-raw-colors": "error",
+    "shadcn/no-restyle": [
+      "error",
+      {
+        "allow": ["layout"],
+        "contracts": [
+          {
+            "pattern": "^Sidebar$",
+            "allow": [
+              "layout",
+              "border-r",
+              "transition-none",
+              "inbox-sidebar",
+              "inbox-list-panel",
+              "support-sidebar",
+              "support-list"
+            ]
+          },
+          {
+            "pattern": "^SidebarHeader$",
+            "allow": ["layout", "py-4", "gap-4", "border-b", "p-5"]
+          },
+          {
+            "pattern": "^SidebarGroup$",
+            "allow": ["layout", "px-3"]
+          },
+          {
+            "pattern": "^SidebarFooter$",
+            "allow": ["layout", "px-3", "pb-4"]
+          },
+          {
+            "pattern": "^SidebarMenuButton$",
+            "allow": ["layout", "p-0"]
+          },
+          {
+            "pattern": "^Label$",
+            "allow": ["layout", "deck-checkbox"]
+          },
+          {
+            "pattern": "^Textarea$",
+            "allow": ["layout", "text-sm", "leading-7", "journal-summary"]
+          },
+          {
+            "pattern": "^MessageScroller$",
+            "allow": ["layout", "research-conversation"]
+          },
+          {
+            "pattern": "^MessageScrollerContent$",
+            "allow": ["layout", "gap-5", "p-4"]
+          },
+          {
+            "pattern": "^Marker$",
+            "allow": ["layout", "research-tool-message"]
+          },
+          {
+            "pattern": "^Message$",
+            "allow": ["layout", "research-message"]
+          },
+          {
+            "pattern": "^Collapsible$",
+            "allow": ["layout", "research-account-picker"]
+          },
+          {
+            "pattern": "^SidebarProvider$",
+            "allow": [
+              "layout",
+              "workspace",
+              "home-workspace",
+              "inbox-workspace",
+              "vital-workspace",
+              "support-workspace",
+              "journal-workspace"
+            ]
+          },
+          {
+            "pattern": "^Button$",
+            "allow": ["layout", "auth-submit", "inbox-back", "support-back"]
+          },
+          {
+            "pattern": "^SidebarInset$",
+            "allow": ["layout", "home-main", "inbox-reader", "support-main", "journal-main"]
+          },
+          {
+            "pattern": "^Input$",
+            "allow": ["layout", "pl-9"]
+          },
+          {
+            "pattern": "^SidebarContent$",
+            "allow": ["layout", "gap-0"]
+          },
+          {
+            "pattern": "^Badge$",
+            "allow": ["layout", "deck-source-label"]
+          }
+        ]
+      }
+    ],
+    "shadcn/no-unknown-classes": "error",
+    "shadcn/require-static-classes": "error"
+  },
+  "overrides": [
+    {
+      "files": ["scripts/**"],
+      "rules": {
+        "no-console": "off"
+      }
+    },
+    {
+      "files": ["src/components/ui/**"],
+      "rules": {
+        "shadcn/no-arbitrary-values": "off",
+        "shadcn/no-restyle": "off",
+        "shadcn/require-static-classes": "off"
+      }
+    },
+    {
+      "files": ["src/**/*.{test,spec}.{ts,tsx}", "tests/**/*.{ts,tsx}"],
+      "plugins": ["vitest"],
+      "rules": {
+        "typescript/unbound-method": "error",
+        "vitest/expect-expect": "error",
+        "vitest/no-conditional-expect": "error",
+        "vitest/no-standalone-expect": "error",
+        "vitest/require-mock-type-parameters": "error"
+      }
+    },
+    {
+      "files": ["e2e/**/*.{ts,tsx}"],
+      "rules": {
+        "react/rules-of-hooks": "off"
+      }
+    }
+  ],
+  "ignorePatterns": [
+    "**/.pnpm-store/**",
+    "**/.direnv/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/playwright-report/**",
+    "**/test-results/**",
+    "**/.vercel/**",
+    "**/drizzle/**",
+    "**/*.tsbuildinfo",
+    ".output/**",
+    ".tanstack/**",
+    "src/routeTree.gen.ts",
+    "e2e/generated/**",
+    "src/features/storage/migrations.generated.ts"
+  ]
+}

README.md

@@ -1,41 +1,94 @@
-# Twitter Lite
+# Personal Workspace
 
-Twitter Lite is an intentional, read-only X reader. It shows content only after
-you enter a user handle, profile URL, search query, or list URL, follow a
-deliberate post detail link, or manually open a valid
-`/:handle/status/:tweetId` URL.
+A personal workspace for understanding the day, choosing the next action,
+keeping context, and exploring information. Home brings together a short brief,
+flexible tasks and routines, messages, notes, and reading. A shared sidebar opens
+each dedicated workspace; its bottom avatar manages connected accounts.
 
-## Scope
+The interface is in English. User-entered text and external posts retain their
+original language.
 
-- User timelines and raw X search syntax
-- Popular (`Top`) and chronological (`Latest`) search
-- Optional `filter:follows` search
-- Authenticated account list selection and list timelines from a deliberate URL or ID
-- Infinite cursor pagination with explicit retry
-- Deliberate post detail pages with the visible conversation
-- Infinite conversation loading with explicit continuation retry
-- Read-only cards for text, media, quotes, articles, and quiet engagement counts
+## Workspaces and current status
 
-It intentionally has no home feed, recommendations, trends, notifications,
-history, account directory, or write actions.
+| Workspace | Route      | Current implementation                                                                                                 |
+| --------- | ---------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Home      | `/`        | State-derived daily brief, flexible tasks and routines, and natural-language action proposals. Local prototype.        |
+| Messages  | `/support` | Sample conversations, editable replies, scheduling previews, and deferral. Sending is simulated.                       |
+| Journal   | `/journal` | Notes, resume points, medication and weight entries, append-only corrections, and summary previews. Local prototype.   |
+| Reader    | `/inbox`   | Searchable sample articles and a responsive article reader. Recommendation from activity history is not connected yet. |
+| Vitals    | `/vitals`  | Body and Environment dashboards with sample readings, charts, and simulated controls. No health or device connection.  |
+| Research  | `/deck`    | Twitter and Mastodon columns, connected accounts, persistent decks, and optional Codex research chat.                  |
 
-Post detail pages show only the selected post and its visible conversation;
-they do not add related-post recommendations or an account-discovery surface.
+Home, Messages, and Journal share in-memory state across navigation; reloading
+resets it. The home input uses a deterministic English/Japanese interpreter to
+preview an action before confirmation, rather than an LLM. Research decks,
+connections, and chat history use server-side persistence.
 
-## Routes
+See [execution support](docs/execution-support.md) and the
+[vitals preview](docs/vitals-preview.md) for prototype scope.
 
-- `/` shows the empty user input.
-- `/:handle` shows a user timeline.
-- `/search?q=<query>&product=<Top|Latest>&following=<boolean>` shows search results.
-- `/i/lists` shows the authenticated account's lists.
-- `/i/lists/:listId` shows a list timeline.
-- `/:handle/status/:tweetId` shows one selected post and its visible conversation.
+## URL state
+
+Reader search and article selection, Messages views and conversations, Home
+previews, account management, Journal review/correction views, and Vitals
+navigation are represented in search parameters. Research uses deck, run, and
+citation IDs. Reloading or browser Back/Forward restores the view while its
+underlying data remains available. Login preserves the requested workspace URL.
+
+Explicit selections add browser history; search input replaces it after a
+300 ms debounce using TanStack Pacer. Navigation cancels pending search updates,
+and IME composition waits until confirmed. URL navigation never submits prompts,
+sends messages, or repeats device actions. Drafts, secrets, results, and task
+contents remain outside the URL. Unsaved mock records and manual temporary
+decks still disappear on reload; a URL does not persist their contents.
+
+## Direction: personal context and execution
+
+The intended connection with the separate private `life` / Rensheng repository
+is a loop: read relevant personal context, suggest useful next actions, record
+what happened, and compile meaningful outcomes back into durable context.
+This integration is planned; the app does not currently read or update life.
+
+Rensheng would retain personal context, preferences, and the background of
+ongoing matters. This workspace would own its execution state and interaction
+history, with original conversations and appointments remaining in their source
+systems. Context should carry source references and verification dates.
+
+Interests are queries over activity history, not settings the user must maintain.
+Routines provide optional guidance rather than a daily completion quota. Home
+should help the user choose a manageable next step, with room to defer, dismiss,
+or change direction.
+
+## Research capabilities
+
+- Multiple named decks with up to six columns each
+- Twitter search, user timelines, and lists with independent relay accounts
+- Mastodon OAuth, multiple accounts, search, user, list, and hashtag columns
+- Native X search syntax, Top/Latest ranking, and optional `filter:follows`
+- List discovery for the account selected in the column editor
+- Column editing, ordering, deletion/undo, refresh, and cursor pagination
+- SQLite-backed shared decks, revision conflicts, and URL-based selection
+- Temporary views for exploration, with explicit saving
+- Server-only encrypted Mastodon credentials and configurable Tailscale owner access
+- Read-only post cards with source links, text, media, and quotes
+- Experimental WebMCP tools to manage decks and read their columns
+- Optional resident Codex research chat, cited host-side Markdown reports,
+  and saved conversations with deck, account, and citation restoration
+
+Original-post links open their source site; SNS reply threads are not rendered
+inside the app. Bluesky, Threads, and Nostr connectors are not implemented.
+
+## Login and onboarding
+
+The workspace requires a single owner account with email and password. First
+use opens account setup, followed by a short onboarding. Run
+`nix develop -c pnpm account:setup` on the server to obtain the private setup
+code. See [owner login](docs/login.md) for configuration, sessions, and limits.
 
 ## Requirements and setup
 
 Use Nix, or Node.js `>=22.12.0` with pnpm `11.9.0`. The committed `.npmrc`
-routes the `@yuta` scope to the public Gitea Packages registry, where Bird
-`0.10.0` provides the required Top and Latest search interface.
+routes the `@yuta` scope to the public Gitea Packages registry.
 
 ```bash
 nix develop -c pnpm install --frozen-lockfile
@@ -43,48 +96,235 @@ cp .env.example .env.local
 ```
 
 The Nix development shell installs Hallmark's agent skill for the supported
-local agent targets.
-
-Set `TWITTER_RELAY_BASE_URL` in `.env.local` for Vite development, and set
-`BIRD_PROFILE_NAME` when the relay has multiple profiles. Export the same
-values in the process environment before `start` or `test:live`:
+local agent targets. Set the runtime configuration in `.env.local` for Vite
+development, or export it before running the production server. In addition to
+the relay URL, configure the Serve origin, owner login, and an absolute SQLite
+path from `.env.example`. Mastodon needs an allowed instance and a runtime
+encryption key file; see [storage, OAuth and restore](docs/storage-and-oauth.md).
 
 ```bash
 export TWITTER_RELAY_BASE_URL=http://127.0.0.1:6900
-export BIRD_PROFILE_NAME=
 ```
 
-Both values are read by server-only code at runtime; neither value nor Bird is
-sent to the browser.
+The app discovers available account profiles through the relay's `/profiles`
+endpoint. Select a profile for each column. There is no global account selector,
+profile cookie, or application-level `BIRD_PROFILE_NAME` default. Requests
+validate that the bound profile still exists before fetching posts or lists.
+Bird and relay credentials stay on the server; saved deck definitions include
+stable connection IDs. The connection metadata resolves Twitter IDs to relay
+profiles; Mastodon credentials never go to the browser.
 
 ## Commands
 
 ```bash
 nix develop -c pnpm dev
 nix develop -c pnpm dev:tailscale
+nix develop -c pnpm generate:e2e-openapi
+nix develop -c pnpm lint
+nix develop -c pnpm format
+nix develop -c pnpm format:check
+nix develop -c pnpm typecheck
 nix develop -c pnpm knip
 nix develop -c pnpm test
 nix develop -c pnpm test:e2e
 nix develop -c pnpm test:live
 nix develop -c pnpm build
 nix develop -c pnpm start
+nix develop -c pnpm account:setup
+nix develop -c pnpm db:generate
 ```
 
-`test:e2e` is intentionally Nix-only and uses the system Chromium supplied by
-the dev shell. Browser tests are organized under `e2e/`: page object models
-and fixtures are shared by integration flows and Axe checks for WCAG 2.0/2.1
-A and AA. `test:live` is an explicit, opt-in smoke test that performs exactly
-one read-only Top search using the configured relay.
+## Home Codex research prototype
 
-Development binds to `127.0.0.1` by default. `dev:tailscale` binds to
-`0.0.0.0`, so it exposes the app on LAN interfaces as well as Tailscale. Use it
-only on a trusted network and obtain the Tailscale address with
-`tailscale ip -4`.
+Run `codex login` as the host user. The backend uses Vercel AI SDK 7 and
+`ai-sdk-provider-codex-cli` 2.3 to manage a local Codex app-server over stdio.
+A separate WebSocket service is no longer required. Use Codex CLI 0.156.0 or
+newer; set an explicit executable path if it is not on PATH.
+The child receives an environment allowlist; inherited MCP servers, hooks,
+web search and multi-agent execution are disabled for these research turns.
+The user's Codex settings are not changed.
+
+Configure the web app in `.env.local`:
+
+```dotenv
+TWITTER_LITE_CODEX_MODEL=gpt-6-astra
+TWITTER_LITE_REPORT_ROOT=/absolute/path/to/twitter-lite/.data/research
+# Optional:
+# TWITTER_LITE_CODEX_PATH=/absolute/path/to/codex
+```
+
+This provider does not register AI SDK `tools` as Codex dynamic tools.
+The existing validated, account-scoped research functions are exposed through
+its in-process `createSdkMcpServer` bridge instead. Streaming uses `streamText`
+and `smoothStream` with 15 ms pacing and Japanese-aware chunking:
+`/[\u3040-\u309F\u30A0-\u30FF]|\S+\s+/`.
+Streamdown renders the Markdown and animates new text only while the final
+assistant message is live; completed history is immediate and reduced-motion
+preferences are respected. `@shadcn/helpers/ai-sdk` supplies deterministic
+streaming fixtures for renderer tests.
+
+Use the chat on the left while browsing horizontally scrollable deck columns on
+the right. Messages continue the same Codex thread and include the currently
+open deck as context. The account selector controls which connections Codex can
+use. It can inspect saved deck definitions and reuse them as temporary views,
+as well as create new views. `list_lists(connectionId)` discovers existing
+Twitter and Mastodon lists for a selected connected account; returned list IDs
+can be reused in list columns. It uses the same catalog as the manual editor
+(Twitter requests up to 100 lists; list discovery is not paginated).
+The default prompt asks Codex to inspect existing decks and the selected
+accounts' lists before planning new searches, then read relevant list columns
+for evidence. Follow-ups can reuse catalogs already fetched in the conversation.
+Manual deck creation and column editing remain
+available. The backend handles tools even when the browser is closed.
+Use **New chat** to leave the current conversation and start a fresh Codex
+thread with your next message. The open deck and host reports remain available.
+A running turn continues in the background when you open another chat.
+Selection belongs to the current URL; another browser does not change it. **Chat history** reopens saved conversations with their account
+selection, deck and citations; the next message resumes the same Codex thread.
+SQLite stores conversation snapshots. Active selection is not stored globally.
+Each turn is limited to 6 columns, 12 upstream requests shared between list
+discovery and post retrieval (at most 20 posts per fetch), and 15 minutes.
+The prototype accepts up to 100 messages per backend process.
+SSE pushes messages, tool activity and deck updates for the requested conversation
+ID, without polling. Separate conversations have independent executions.
+Codex replies render as Markdown, including tables, lists and code. Clicking a
+cited post link scrolls to its card and briefly highlights it. Loaded cards take
+priority; otherwise the app shows the post captured during research in a column
+with matching source and account settings, creating a temporary citation deck
+when needed. These captured posts are labeled and do not change feed pagination
+or reveal sensitive content automatically. Other links still open externally;
+Ctrl/Cmd-click on a citation also opens the original site.
+Citation metadata stays with the saved conversation across reconnects,
+follow-up messages and server restarts. Markdown HTML is not executed and
+Markdown images are rendered as links.
+Reopening the page receives the latest state and restores the temporary deck.
+Later updates modify the same temporary view; they do not overwrite saved decks
+or switch away from another deck you are reading. Use the existing save button
+to persist a deck. The agent and visible columns currently fetch posts separately.
+
+Codex writes `<report root>/<run ID>/report.md` using its workspace file tools.
+The UI displays its host path after validating the file. A conversation or deck
+edit can finish without producing a report. Citation quality is model output,
+not independently verified. Report contents remain on the host filesystem;
+the app DB stores the conversation, thread ID, deck context and citation metadata.
+
+Browser disconnection does not cancel research; reconnecting restores the latest
+state through `/api/research/events?run=<id>`, under the same owner access checks as the
+rest of the app. After a backend restart, unfinished turns appear as interrupted;
+sending another message explicitly resumes the same thread through the provider.
+It does not automatically rerun interrupted requests. Files already written remain.
+Cancellation is explicit. The backend and report directory must
+run under a user able to write those files. NixOS DynamicUser service integration
+and dedicated service credentials are outside this prototype.
+
+`test:e2e` uses the system Chromium supplied by the Nix dev shell. Playwright
+integration and Axe accessibility tests live under `e2e/`. A standalone mock
+HTTP relay exercises the production server-function boundary without contacting
+X or a personal relay. Orval generates API fixture types from a pinned
+[twitter-openapi specification](https://github.com/fa0311/twitter-openapi/commit/590dae5c9f8575abc91d3774946bfe6f23960aba).
+Generated files are committed; run `generate:e2e-openapi` only when changing
+the pin or selected operations. Runtime requests use Bird.
+
+`test:live` is an explicit, opt-in smoke test that performs one read-only Top
+search. For this standalone probe only, `BIRD_PROFILE_NAME` selects the account
+and `TWITTER_LITE_LIVE_QUERY` overrides the search text.
+
+## Deck workspace
+
+The interface uses shadcn/ui's Base UI components and Tailwind CSS v4, with a
+collapsible sidebar based on
+[sidebar-09](https://github.com/shadcn-ui/ui/tree/98a1fe67b439324ddc857f47fbdce056600a4329/apps/v4/registry/bases/base/blocks/sidebar-09).
+The workspace retains compact column headers and independently scrolling post
+columns. On narrow screens, the sidebar opens as a sheet. Add/edit forms use
+shadcn dialogs with Escape handling and focus restoration. Column menus contain
+editing, ordering, and deletion; refresh stays available directly in each header.
+
+Shared UI components live in `src/components/ui`; `components.json` configures
+the registry and theme entrypoint. Chat uses MessageScroller, Message, Bubble,
+Marker and InputGroup with Streamdown, reconnectable snapshot SSE, and saved
+conversations. The icon rail switches between chat and deck management;
+closing the mobile sheet or crossing the desktop breakpoint preserves chat
+drafts, selected accounts and live deck updates. Theme colors are declared in
+`src/ui.css`. The shared entrypoint `src/styles.css` loads the theme, tokens,
+base styles and feature styles in that order, so the UI lint rules can resolve
+application classes through the same stylesheet used by the app.
+
+`pnpm lint` runs Oxlint with type-aware linting and TypeScript checking through
+`oxlint-tsgolint`, including the
+[@shadcn/lint](https://github.com/shadcn-ui/lint) UI checks. The
+`shadcn/no-raw-colors` rule in `.oxlintrc.json` requires theme colors in JSX and
+class helpers, including shared UI components. Layout values remain available
+for the sidebar and deck. Component contracts allow only the existing workspace
+styles; Next.js-specific rules are omitted because this app uses TanStack Start.
+`pnpm format` formats files with Oxfmt defaults, and
+`pnpm format:check` checks formatting without changing files. Knip checks application usage while retaining the public exports
+of registry components for composition. Additional design rules can be configured
+in `.oxlintrc.json`;
+see the [available rules](https://github.com/shadcn-ui/lint#rules).
+
+The database and OpenAPI generators format their output with Oxfmt. TanStack
+Router owns the formatting of `src/routeTree.gen.ts`, which is excluded from
+formatting; `pnpm check:routes` verifies that regeneration leaves it unchanged.
+
+Create a deck for an investigation, then add columns for each perspective.
+Choose a connected account and one of its supported sources. Account
+changes affect only the edited column. Matching source conditions and accounts
+share the query cache; different profiles never share posts or cursors.
+
+Saved decks live on the server and refresh across devices on focus and while
+visible. Conflicting revisions are rejected. Only the active deck is rendered
+and fetched; posts and cursors are not archived. The active selection stays
+local to the device.
+
+AI-created decks open as temporary views reconstructed from their saved chat
+on another device or after reload. Save a view to add it to the independent deck
+library, or make a temporary copy of a saved deck to experiment.
+Other unsaved temporary edits disappear on reload or navigation, including OAuth redirects.
+Existing version-2 browser decks have an explicit import action; invalid older
+data is left untouched. See [the deck model and persistence contract](docs/research-decks.md).
+
+## WebMCP
+
+A WebMCP-enabled browser exposes `list_connections`, `list_decks`, `get_deck`,
+`set_deck`, `save_deck`, `select_deck`, `delete_deck`, `get_column_posts`, and
+`load_more_column` on `/deck`. Discover connection IDs first.
+`set_deck` creates a temporary view when `deckId` is omitted. `save_deck`
+persists it. Replacing or deleting a saved deck requires its `expectedRevision`.
+
+Enable `chrome://flags/#enable-webmcp-testing`, restart Chrome, and open the
+local app. Use the
+[Model Context Tool Inspector](https://developer.chrome.com/docs/ai/webmcp#imitate_agent_chat_with_the_inspector_extension)
+to invoke tools. Registration uses native `document.modelContext` through
+`usewebmcp`; there is no polyfill or external MCP transport. Unsupported
+browsers retain the manual deck UI. See [tool contracts and verification](docs/webmcp-prototype.md).
+
+Development and `dev:tailscale` both bind to `127.0.0.1`. Native WebMCP needs a secure context;
+use a Tailscale Serve HTTPS origin for remote access, and allow its exact
+hostname through `__VITE_ADDITIONAL_SERVER_ALLOWED_HOSTS` in the Vite process
+environment. HTTP and HTTPS origins have separate localStorage.
+
+Set `TWITTER_LITE_ORIGIN` to the exact public HTTPS origin (no trailing slash).
+The default `TWITTER_LITE_AUTH_MODE=tailscale` requires
+`TWITTER_LITE_ALLOWED_LOGIN` to be your Tailscale login. The app requires
+Serve's `Tailscale-User-Login` header and rejects other users. Keep the backend
+on localhost: the trusted Serve proxy supplies identity. Tagged clients do not
+provide user identity. Missing configuration fails closed; direct browser access
+to localhost does not supply the required identity. Playwright supplies an
+explicit fixture identity to its isolated test server.
+
+For a private, tailnet-only reverse proxy such as Traefik, explicitly set
+`TWITTER_LITE_AUTH_MODE=none` to disable the Tailscale identity check. This mode
+does not require `TWITTER_LITE_ALLOWED_LOGIN` or Tailscale identity headers.
+App login remains mandatory, including access to connected accounts and Codex.
+Bind the backend to loopback or its Tailscale address and restrict proxy
+access to the tailnet.
+Both modes require the exact configured `Origin` for state-changing requests,
+including chat and deck mutations. Missing origin or an unknown auth mode
+fails closed. Mastodon OAuth uses the configured public origin for its callback.
 
 ## NixOS service
 
-The flake provides both a production package and a NixOS module. Import the
-module and configure the relay:
+The flake provides a production package and a NixOS module:
 
 ```nix
 {
@@ -100,7 +340,10 @@ module and configure the relay:
           services.twitter-lite = {
             enable = true;
             relayBaseUrl = "http://127.0.0.1:6900";
-            # profileName = "default";
+            publicOrigin = "https://home.example-tailnet.ts.net";
+            allowedLogin = "your-tailscale-login";
+            mastodonOrigins = [ "https://fedi.yutakobayashi.com" ];
+            credentialKeyFile = "/var/lib/secrets/twitter-lite-key";
           };
         }
       ];
@@ -109,15 +352,15 @@ module and configure the relay:
 }
 ```
 
-The service listens on `127.0.0.1:3000` by default. Set
-`services.twitter-lite.host` or `services.twitter-lite.port` to change the
-listener. The package can also be built directly with `nix build`.
+The service listens on `127.0.0.1:3000`. Set
+`services.twitter-lite.port` to change the port; the host remains loopback.
+The module reserves `/var/lib/twitter-lite` with mode 0700 for persistent state.
+`credentialKeyFile` can reference a runtime secret file for SNS credentials;
+systemd loads it as a credential, separate from the database and Nix store.
+Profiles are selected in column definitions, not service options.
+The package can also be built directly with `nix build`.
 
 ## Reliability
 
 Bird uses X's internal GraphQL operations through the configured relay. Query
 IDs and response shapes can change without notice.
-
-Conversation pages use Bird's current per-page chronological ordering. Keeping
-X's original ranked branch order is deferred until Bird exposes that order
-without expanding the relay surface.

biome.json

@@ -1,16 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.5.3/schema.json",
-  "files": {
-    "includes": [
-      "**",
-      "!src/routeTree.gen.ts",
-      "!!**/.output",
-      "!!**/test-results"
-    ]
-  },
-  "formatter": { "enabled": true, "indentStyle": "space" },
-  "linter": { "enabled": true, "rules": { "recommended": true } },
-  "javascript": {
-    "formatter": { "quoteStyle": "single", "semicolons": "asNeeded" }
-  }
-}

components.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "base-nova",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/styles.css",
+    "baseColor": "neutral",
+    "cssVariables": true
+  },
+  "iconLibrary": "lucide",
+  "aliases": {
+    "components": "#/components",
+    "utils": "#/lib/utils",
+    "ui": "#/components/ui",
+    "lib": "#/lib",
+    "hooks": "#/hooks"
+  }
+}

docs/execution-support.md

@@ -0,0 +1,64 @@
+# Execution support prototype
+
+The shared sidebar opens `/support` (Messages) and `/journal` (Journal), alongside
+Reader and Research. These are UI-only prototypes with fictional contacts
+and in-memory state. Reloading resets the prototype state. Tasks, communication status, outcomes, and
+journal entries are shared between routes for the current browser session.
+No messages, calendar events, medical records, or Rensheng pages are written.
+
+## Reference and scope
+
+The functional reference is the user's life brief
+`briefs/2026-09-25-executive-support-design.md`, together with the public
+[Beeper Copilot concept](https://beeper-copilot-lp.vercel.app/).
+The prototype adopts the execution flows, not private facts from the life repo
+or the reference site's deployment and privacy claims.
+
+- Communication: unified conversations, a maximum of three initial actions,
+  deferral, waiting, dismissal, and a full list; source messages, summaries,
+  editable reply styles, explicit review, and simulated sending.
+- Scheduling: choosing a candidate and reviewing a simulated calendar entry.
+- Context: person notes with links back to the sample conversation and a local
+  record of the simulated outcome. No permanent trait or goal is inferred.
+- Journal: free notes, resumption points, user-entered medication and weight
+  records; occurrence and recording times, append-only corrections, and a
+  selectable summary preview for a consultation.
+
+The intended memory boundary remains Rensheng: execution events can eventually
+be compiled into durable context after source comparison and user correction.
+This prototype neither implements that compiler nor creates a second personal
+context database. Missing records remain unknown; there are no medication,
+dose, weight-target, or treatment recommendations.
+
+The UI uses existing shadcn Base UI components and neutral theme tokens.
+Shared account management continues to use the existing connection system;
+the new communication and journal prototypes do not consume those accounts.
+
+## Daily home
+
+`/` presents a greeting, a large input, and a flexible plan grouped as
+Start here, Routines, and If there’s room. There are no fixed time slots.
+Tasks can be reordered, completed, deferred, restored, or followed as routine
+steps. Communications can be reviewed directly in a home dialog; changes also
+appear in `/support`. Journal entries and corrections appear on the home, and
+reader samples open for reading. Research remains a separate work surface.
+
+The input currently uses a deterministic English/Japanese mock interpreter, not an LLM.
+It proposes typed actions for task creation/status/reordering, routine steps,
+contact reply/review or deferral, notes/weight/medication records, and navigation.
+Confirming a proposal dispatches the corresponding operation. Unknown or
+ambiguous input does not change state. Message sending still goes through the
+existing simulated review UI; this prototype performs no external send.
+
+Examples: `Add grocery shopping`, `Defer Morning routine`, `Reply to Aoki`,
+`Note: Resume from page 2`, `Weight: 65.2 kg`, and `Open Reader`.
+
+The interaction reference is [Tiimo visual planning](https://www.tiimoapp.com/product/visual-planning),
+reviewed on 2026-09-28: combined routines and tasks, flexible reordering, small
+steps, and natural-language planning. Unlike its timed scheduling options, this
+prototype deliberately keeps the day free of precise times as requested.
+
+The home greeting includes a short prose brief derived from current task and
+communication state. Completed or deferred items leave the brief; the next
+contact opens directly from the text. A current resumption note takes precedence
+over the optional-task suggestion. This is local templated copy, not an LLM report.

docs/login.md

@@ -0,0 +1,65 @@
+# Owner login and onboarding
+
+This is a single-owner workspace. App login is mandatory for all workspace
+pages, server functions, and research streams. The existing Tailscale identity
+check is an optional outer boundary; `TWITTER_LITE_AUTH_MODE=none` disables only
+that outer check, not app login. Origin checks still protect mutations.
+
+## First use
+
+Start the server with its usual database and public-origin configuration, then
+run this on the server using the same database:
+
+```bash
+nix develop -c pnpm account:setup
+```
+
+The Nix package also provides `twitter-lite-setup`; run it with the service
+database path and filesystem permissions.
+
+The command loads `.env.local` when present. An exported `TWITTER_LITE_DB_PATH`
+takes precedence. It prints a setup code for `/setup`; keep that code private.
+The code is created in `<database path>.setup-token` with mode 0600, or supplied
+through `WORKSPACE_SETUP_TOKEN` (at least 32 characters). It is never returned
+by the app's public API. The owner account can be created only once, including
+when two setup requests arrive together. The code cannot register another
+account or reset an existing password after setup.
+
+Visit the app, enter the setup code, your name, email, and a password of 15–128
+characters. The email is a login identifier; this prototype does not verify it
+or send email. Choose your display name and finish the short onboarding to
+open Home. Onboarding completion and the name persist in SQLite. Home greets
+you by that name.
+
+## Sessions
+
+Passwords use salted scrypt hashes (N=2^17, r=8, p=1). Session cookies are
+HttpOnly, SameSite=Lax, host-only, and Secure for an HTTPS public origin.
+Only token hashes are stored in SQLite; sessions expire after 30 days.
+Setup and login share a persistent limit of 10 attempts per 15 minutes;
+successful authentication clears that limit.
+
+Open the avatar menu and choose **Sign out** to revoke the current session.
+Open research streams stop sending updates when the session is revoked or
+expires, with an idle check every 15 seconds. Other logged-in devices retain
+their own sessions. Authenticated responses are not cached.
+
+Account registration is closed once the owner exists. Multiple users,
+email-based password recovery, and account management are not implemented.
+Back up the SQLite database as described in [storage](storage-and-oauth.md).
+Home tasks, messages, and journal entries remain session-local prototypes;
+onboarding does not make those records persistent.
+
+## Implementation
+
+- `src/features/auth/auth.server.ts`: owner, password hashing, throttling, sessions.
+- `src/features/auth/gate.server.ts` and `src/start.ts`: request-level protection.
+- `/api/auth`: session state, setup, sign-in, onboarding, and sign-out.
+- Root route guard: client navigation and onboarding redirects.
+- `/setup`, `/login`, `/onboarding`: English forms using the existing UI system.
+
+Password and session handling follow the relevant
+[OWASP password storage](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html)
+and [session management](https://cheatsheetseries.owasp.org/cheatsheets/Session_Management_Cheat_Sheet.html)
+guidance. Tests cover invalid credentials, bootstrap ownership, expiry,
+revocation, request protection, and onboarding persistence.

docs/plans/2026-09-24-home-agent-research.md

@@ -0,0 +1,291 @@
+# Home-agent research
+
+Historical design: the WebSocket transport and global active selection described
+here were replaced by the [AI SDK research runtime](../research-runtime.md).
+
+## Product boundary
+
+The user starts a research task from the deck workspace. A home agent chooses
+sources, opens a temporary deck, reads posts and writes a cited Markdown report
+on the host. Twitter Lite provides the connected-account and deck tools; the
+agent owns research and report writing.
+
+SQLite stores conversation snapshots and the selected conversation alongside
+saved deck definitions and account credentials. Reports remain host Markdown;
+their contents are not copied into the DB. Adding a temporary deck to the saved
+deck library remains an explicit user action.
+
+## Proposed first implementation
+
+1. Add a topic and connected-account selection form to the deck workspace.
+2. Start one home Codex task with a dedicated output directory.
+3. Supply tools for connection discovery, temporary deck creation and bounded
+   post retrieval using the existing validators and platform services.
+4. Save conversation state and the latest generated deck in SQLite. SSE
+   sends the current snapshot on connection and pushes subsequent changes.
+   Reopened pages restore the temporary view; later definitions update the same
+   view. Closing that view does not delete the report or stop the agent.
+5. Have the agent write `report.md` in its per-task directory with original post
+   URLs, collection limits and failed sources. Show progress and the output
+   location in the app. No report-history UI or scheduled execution yet.
+
+Following the user's WebSocket question, the proposed transport is a persistent
+`codex app-server --listen ws://127.0.0.1:4500` connected to the Node backend,
+with dynamic tools handled by that backend. WebSocket transport is currently
+experimental in the official documentation. Native browser WebMCP is not a remote
+MCP endpoint: reuse application operations rather than assuming that host Codex
+can directly invoke a user's browser tools. No externally exposed Codex socket
+is necessary.
+
+## Decisions
+
+- Confirmed: use home Codex, rather than a separate OpenAI API integration.
+- Confirmed: report artifacts are host Markdown files written by the agent.
+- Prototyping: resident app-server over loopback WebSocket, using the existing
+  Codex login and model `gpt-6-astra`. No NixOS service migration in this step.
+- Configure a dedicated report root and Codex authentication store. Preserve
+  refreshed authentication for the service; do not put credentials in prompts
+  or copy application secrets into the child environment.
+- Keep manual execution bounded and cancellable. After restart, unfinished
+  conversations restore as interrupted. The next user message resumes the same
+  Codex thread after stopping any surviving orphan turn. No automatic rerun or
+  durable job queue is added.
+
+## Conversation workspace
+
+The next iteration places a persistent chat beside the horizontally scrollable
+deck. The browser displays user messages, public Codex agent messages and tool
+activity from app-server events. Each follow-up continues the existing thread
+and supplies the deck currently open in that browser. Internal reasoning is not
+part of this transcript.
+
+The agent can list and inspect saved decks within the selected account scope,
+then reuse their columns in a temporary view. Saved definitions remain unchanged
+until the user saves a view. Existing manual creation, selection, column editing
+and saving stay available alongside the chat.
+
+`list_lists(connectionId)` also exposes the manual editor's Twitter and Mastodon
+list catalogs. Discovery is read-only and checks the selected connected account
+before contacting either provider. Returned list IDs can be used directly in
+list-column sources. Discovery and post retrieval share the per-turn budget of
+12 upstream calls, including failures. Twitter requests up to 100 entries through
+the existing catalog service; discovery has no pagination yet.
+For Twitter, the agent prefers the selected connected account named `account2`
+for new columns and retrieval, resolving its ID through `list_connections`.
+It uses another selected account when `account2` is unavailable, lacks access
+(for example to a private list), or the user explicitly requests it. Existing
+columns retain their account bindings.
+
+The default agent instructions require this discovery at the start of research,
+before planning new searches. Relevant existing lists become candidate sources;
+their posts are retrieved through the regular column tool. Catalogs already read
+in the conversation can be reused, and explicit user instructions take priority.
+
+A conversational turn need not produce a research report: discussing a query or
+editing a deck is a valid completed turn. Reports, when requested, remain host
+Markdown files. SSE snapshots include the conversation and latest generated
+deck so reopening a page restores both without restarting work or polling.
+
+The chat header can reset an idle conversation. The next message starts a new
+Codex thread while retaining the browser's current deck as context. Reset pushes
+an empty conversation to every subscriber, preserves host reports and does not
+delete deck definitions. Active turns must be stopped first; a stale reset must
+not clear a newer conversation started on another device. The history selector
+can reopen previous conversations while idle, restoring the generated deck (or
+last supplied deck context), selected accounts and citations. Selection is shared
+through SSE. Stale selections are rejected just like stale resets.
+
+`research_sessions` stores the full public conversation snapshot and summary
+metadata; `research_state` stores the selected conversation, including an explicit
+blank selection for new chat. State is written before starting Codex and before
+publishing updates. DB write failures stop research and surface a save error.
+On restore, formerly active sessions become interrupted. `thread/resume` restores
+Codex's persisted dynamic tools. Recovery suppresses old turn notifications and
+tool calls, interrupts a still-running old turn, then starts the new message.
+
+## Markdown and source navigation
+
+Assistant messages use react-markdown with remark-gfm. Public tool messages and
+user input remain plain text. Markdown links retain their original URLs; a
+regular click on a known post navigates within the deck, while modified clicks
+and unrelated URLs retain external navigation.
+
+Successful agent post fetches capture the exact column definition and a public
+post projection in the saved conversation. The projection excludes raw
+provider responses, HTML, media and account credentials. References are retained
+across turns, updated per source/account/post identity and retained in chat history.
+The agent is instructed to cite exact returned post URLs in Markdown.
+
+Navigation prefers a loaded card, then a workspace column with the same source
+and connection. Missing sources open a one-column temporary deck. An unloaded
+reference is displayed as a labeled research-time post without altering the
+query cache or pagination. Cards receive focus, scroll into view and briefly
+highlight; reduced-motion settings are respected and sensitive content stays
+collapsed.
+
+## Verification
+
+- Protocol tests for dynamic-tool requests, failures, cancellation and process
+  exit, with no real model usage in ordinary tests.
+- Tool tests for selected connection scope, source validation, pagination limits
+  and temporary-only deck creation.
+- Browser test: start task, show generated temporary deck, retain manual save,
+  display progress and completion or failure.
+- Opt-in real home Codex run: retrieve real posts and verify a readable report
+  exists at the reported host location with original-source links.
+
+## Deployment boundary
+
+The currently used UM790-Pro runs the development server. The existing dotnix
+Twitter Lite service is configured on B450M-Pro4 with obsolete options and a
+different public route. Do not apply that configuration to this task implicitly.
+Service migration and backup scheduling need a concrete host configuration;
+they are separate from validating this first agent workflow.
+
+## References
+
+- [Codex App Server](https://learn.chatgpt.com/docs/app-server)
+- [Codex authentication](https://learn.chatgpt.com/docs/auth)
+- [Existing WebMCP contract](../webmcp-prototype.md)
+
+## Web-to-resident-Codex examples inspected
+
+Research on 2026-09-24; README and implementation inspection only, not runtime
+validation or adoption of these projects.
+
+- [Redex](https://github.com/ladnir/redex/tree/a8032c49d1c9cc79db9679ad06b94a72defe3ec7):
+  its Python HTTP/SSE bridge connects to a standalone Codex app-server through
+  WebSocket. `src/redex/app_server.py` initializes the connection and sends
+  `thread/resume` then `turn/start`; `src/redex/bridge.py` has a long-lived
+  `LiveEventHub` separate from browser SSE connections. Desktop shared-runtime
+  integration in this project's README requires its Codex fork; standalone
+  WebSocket usage does not. The bridge suppresses the Origin header on its
+  server-side connection because Codex rejects browser-style Origin headers.
+- [Pedregoneric/codex-webui](https://github.com/Pedregoneric/codex-webui/blob/5cbc718004c77657812f7151ae708e68cc6b398c/server.js):
+  a small personal/Tailscale-oriented example. One `CodexBridge` owns a long-lived
+  stdio child. Browser SSE close removes that subscriber, without killing Codex;
+  gateway shutdown does kill the child. This demonstrates that browser lifetime
+  independence is not itself a WebSocket feature. Its authentication is separate
+  from the existing Tailscale identity boundary used by Twitter Lite.
+- [OpenAI's Codex Web architecture](https://openai.com/index/unlocking-the-codex-harness/):
+  the February 2026 engineering article describes HTTP/SSE from browser to
+  backend, and a worker maintaining a long-lived app-server connection. The
+  backend owns task state so browser disconnection does not stop work. This is an
+  architectural reference, not evidence of today's exact hosted implementation.
+- [nathan-chappell/codex_web_ui](https://github.com/nathan-chappell/codex_web_ui/tree/79be149c427040d7fbb94246d841f705ab53ce9e):
+  the launcher starts a detached app-server on a private Unix socket. Its
+  TypeScript bridge performs a WebSocket upgrade over that socket. Browser
+  commands use HTTP RPC and events use SSE. Disconnecting an SSE subscriber does
+  not stop the bridge or Codex. Relevant files: `bin/codex-web-ui.js`,
+  `server/codexBridge.ts`, `server/appApi.ts`, `server/eventHub.ts`.
+- [seo-rii/codex-webui](https://github.com/seo-rii/codex-webui/tree/2619d78c55c6095aa8b9a7a1412fd0c7abf5e564):
+  the Rust gateway connects directly over Unix-socket WebSocket in current code,
+  despite older docs mentioning a proxy. It separates browser disconnect from
+  gateway-restart handoff and normal shutdown. Request-ID deduplication avoids
+  executing replayed mutations twice. Its dynamic-tool response handling is a
+  useful reference, but we did not find custom SNS-style tool registration to
+  reuse. Relevant files: `backend/src/codex_app_server.rs`,
+  `backend/src/ws_transport_support.rs`, `backend/src/runtime_request_support.rs`.
+
+The implementation should distinguish three events: browser disconnection,
+Twitter Lite backend restart, and Codex process restart. A WebSocket connection
+alone does not guarantee recovery across any of them. Agent tool requests should
+be handled by the backend so research can continue without the initiating tab.
+
+## Prototype verification
+
+- Implemented a loopback WebSocket client, background run controller, bounded
+  account/deck/post tools, and a sidebar research dialog. No schema migrations.
+- 261 unit/component tests passed (one existing opt-in live test skipped).
+- Relevant Playwright coverage: 17 desktop cases, 6 mobile WebMCP cases, and
+  11 mobile deck/research cases passed. The new sidebar action initially
+  overlapped another mobile control; it now uses the existing compact pattern.
+- Typecheck, lint, knip, and production build passed.
+- A real Codex 0.156.1 / gpt-6-astra run started from the browser. The browser
+  was closed, reopened, and observed the task continuing to completion.
+  Local verification supplied the trusted Serve identity and origin headers;
+  the tagged host cannot authenticate as the owner through Serve itself.
+- Codex generated two temporary columns, retrieved 20 Twitter posts and zero
+  Mastodon results, and wrote a Japanese report with original post links and
+  explicit limits on interpreting the empty Mastodon search. The report is
+  under the ignored `.data/research/<run ID>/report.md` directory.
+- Reopening the run's generated deck produced two temporary columns. Saved
+  user decks were not replaced, and the report was not inserted into SQLite.
+- After replacing polling with SSE, six desktop/mobile E2E cases passed for
+  initial snapshots, reconnect snapshots, owner checks and the unconfigured UI.
+- A second real run pushed a one-column deck to the page. After closing and
+  reopening the browser, the latest deck restored automatically and grew to two
+  columns through SSE. Codex then completed `report.md`. Same-view updates,
+  preserving saved decks, ordered asynchronous updates and late start responses
+  are also covered by component/controller tests.
+- The actual Codex launcher was restarted successfully with configured MCP
+  servers disabled; WebSocket `config/read` confirmed all seven disabled. Nix
+  wrapper config overrides must precede the `app-server` subcommand.
+
+## Conversation workspace verification
+
+- 270 unit/component tests and 40 desktop/mobile Playwright cases passed.
+  Typecheck, lint, knip and production build passed.
+- Browser coverage includes conversation/deck restoration from SSE snapshots,
+  manual deck editing and saving, narrow viewports and existing WebMCP tools.
+  Readiness checks wait for usable controls rather than network idleness because
+  the event stream intentionally stays connected.
+- A real three-message Codex conversation called `list_decks`, reused a manually
+  created column from the current-deck context, and edited that column after the
+  browser was closed and reopened. The app-server thread ID and generated deck
+  ID stayed unchanged; the deck advanced from version 1 to 2.
+- The live database had no saved decks, which Codex reported correctly. Saved
+  deck discovery/reuse with populated records is covered by isolated tool tests.
+  The live check did not add or change saved deck records or create a report.
+
+## List discovery verification
+
+- 279 unit/component tests passed (one opt-in live test skipped), with typecheck,
+  lint and production build passing. Tool tests cover both platforms, selected
+  account scope, empty lists, upstream failures, shared request limits and using
+  discovered IDs to create and fetch list columns.
+- A real browser-initiated Codex run discovered 54 lists for Twitter account1
+  and zero for Mastodon, then opened a temporary list column. Reopening the page
+  restored that deck and the conversation. Twitter account2 initially returned
+  an upstream `Dependency: Unspecified` error; a direct retry through the same
+  Bird catalog API returned three lists. A follow-up message in the same Codex
+  conversation then retried `list_lists` successfully and also reported three.
+
+## New-chat verification
+
+- 284 unit/component tests and eight desktop/mobile research E2E cases passed,
+  along with typecheck, lint and production build.
+- A real Codex check on a separate development server reset a completed chat
+  across two browser pages, cleared the draft and retained the current deck.
+  The next message used a different thread ID, contained only the new user
+  message and received the current deck context. The separate server avoided
+  interrupting research already running in the public workspace.
+
+## Markdown citation verification
+
+- The full suite passed 306 unit/component tests, with one opt-in test skipped.
+  Typecheck, lint, knip and production build passed. Follow-up card tests verify
+  re-scrolling when a captured post is replaced by its loaded feed result.
+- 42 desktop/mobile E2E cases passed, including Markdown tables and emphasis,
+  navigating to an offscreen column, captured-post display, focus/highlight,
+  accessibility and existing manual deck/WebMCP operations.
+- A real Codex run on a separate development server fetched 20 Twitter posts,
+  cited two in a Markdown response, and navigated from a citation to its card.
+  Closing and reopening the page preserved working citation navigation.
+- react-markdown 10.1.0 and remark-gfm 4.0.1 were added with the user's approval.
+  The pnpm dependency hash was updated and the x86_64-linux Nix package built.
+
+## Conversation persistence verification
+
+- SQLite repository tests reopen file-backed databases and verify conversation,
+  deck, account, citation and active-selection restoration, plus transaction rollback.
+- Runner tests recreate the service against the same database, resume its thread,
+  reject stale history switches, interrupt orphan turns and reject late orphan
+  events. Failed writes prevent new execution or stop further tool calls.
+- 52 desktop/mobile E2E cases passed. The final focused research suite passed
+  120 tests; typecheck, lint, knip and Nix packaging passed.
+- An actual Codex run captured 20 Twitter posts. A fresh Node process restored
+  that conversation and used the same Codex thread and dynamic tools to add a
+  second column, retaining all citations. Separate desktop/mobile browser
+  contexts restored the saved chat, navigated citations, shared history selection
+  through SSE and retained blank-new-chat selection across reload.

docs/plans/2026-09-24-mastodon-and-shared-decks.md

@@ -0,0 +1,141 @@
+# Mastodon複数アカウント・デッキ端末間共有の実装計画
+
+状態: 機能実装・検証済み。2026-09-24に現行コード・公式仕様・Elkを調査。Drizzle ORM 0.45.3＋Drizzle Kit 0.31.11＋better-sqlite3 13.0.3と、Tailscale Serveの本人情報による利用制限を採用。実機確認の範囲と運用上の引き継ぎは以下に記録する。
+
+## 実装・検証記録（2026-09-24）
+
+- T0〜T6の機能を実装。ユーザーのブラウザでTailscale経由のMastodon認可・callback復帰を確認。
+- サーバーはタグ付き端末なので、本人loginはSelf.UserIDから推測せず実際のユーザー情報で設定。タグ付き端末からの本人情報なしアクセスは引き続き拒否。
+- 単体・統合202件、Playwrightの共有デッキ／WebMCP／アクセス制限38件と接続管理／callback4件を検証。
+- 別ブラウザから保存済み認可を再利用し、実Mastodonを20件→40件へページ送り。同じ一時ビューでTwitter20件を取得。ブラウザエラーなし。確認用ビューは永続保存していない。
+- Nixパッケージ単体で起動・3マイグレーション・DB書込・バックアップを確認。依存hash更新済み。
+- 実アカウントでの接続はMastodon1件。同一インスタンスの複数アカウント・別インスタンス・再接続・解除・401競合・429はテストで検証し、実アカウントを増減させる破壊的試験は行っていない。
+- NixOSサービスの実機デプロイは行わず、モジュール・永続ディレクトリ・credential設定と運用手順を用意。試用用devサーバーを稼働。
+
+## 前提と到達点
+
+- 自分専用。自宅の1台でアプリを稼働し、複数の自分の端末からTailscale ServeのHTTPSで利用する。
+- 同じデッキにTwitterとMastodonを並べ、各カラムに接続アカウントを固定できる。
+- 端末AでOAuth接続とデッキ作成を済ませれば、端末Bでも同じ接続・デッキを使える。
+- デッキ定義・カラム順序・接続一覧を共有する。開いているデッキ、スクロール位置、編集中のフォームは端末ローカルとする案。
+- AIが調査ごとに作るデッキは一時ビューとして開き、必要なものだけ保存済みデッキにする。一時ビューは端末間共有の対象外。
+- 投稿の収集アーカイブ、AIサマリー、オフライン編集、他人との共同編集はこの増分に含めない。
+
+## 推奨構成
+
+```mermaid
+flowchart LR
+  A[PC / スマホ] --> B[Tailscale Serve HTTPS]
+  B --> C[Twitter Lite / localhost]
+  C --> D[(SQLite / 自宅のローカルディスク)]
+  C --> E[Twitter Safe Relay]
+  C --> F[Mastodon各インスタンス]
+```
+
+SQLiteを採用する案。端末が増えても、各端末がSQLを実行するのではなく、同じアプリサーバーへアクセスする。デッキ設定とOAuth情報の小さな更新には単一サーバーのSQLiteで始められると判断する。DBファイルを端末間コピーしたり、NAS上のファイルを複数サーバーから直接開いたりしない。
+
+| 候補                 | 今回の評価                                                                                                   |
+| -------------------- | ------------------------------------------------------------------------------------------------------------ |
+| SQLite               | 推奨。別DBサービス不要。ローカルディスク、短いトランザクション、マイグレーション、復元試験を用意する         |
+| PostgreSQL           | 複数アプリサーバーや大量の並列収集へ進む時に再評価。現時点では運用対象が増える                               |
+| ブラウザDB＋同期基盤 | 採用しない。今回必要なのはオンラインで同じサーバー状態を読むこと。オフライン同期エンジンを導入する必要はない |
+
+SQLiteは同時書き込みが1つという制約がある。複数サーバー・高い書き込み並列度ではclient/server DBを検討する。[SQLiteの用途](https://www.sqlite.org/whentouse.html)
+
+## 認証と保存の境界
+
+アプリの利用許可とSNSアカウントのOAuthを分ける。最初は単一の私用ワークスペースとし、アプリ内のユーザー登録・パスワード管理は作らない。
+
+Tailscale Serveの本人情報を利用する場合は、自分のloginを許可し、バックエンドをlocalhostに束縛する。現在の試用用 `0.0.0.0` 起動を、そのまま本人情報ヘッダーを信頼する本番構成に持ち込まない。タグ付き端末のアクセスには通常のユーザー情報ヘッダーが付かないため、最初の実機確認に含める。Serveからの経路、利用許可、変更リクエストのOrigin検証を共通化する。[Tailscale Serve identity headers](https://tailscale.com/docs/features/tailscale-serve#identity-headers)
+
+OAuth callbackは固定のHTTPS URLにする。認可後に戻る主体はブラウザなので、その端末がtailnetへ到達できる構成を実機検証する。callbackのためにFunnelでアプリ全体を公開する方針は取らない。
+
+## 保存モデル案
+
+| 保存対象                 | 主な内容                                                                                 |
+| ------------------------ | ---------------------------------------------------------------------------------------- |
+| `decks`                  | ID、名前、revision、更新日時                                                             |
+| `deck_columns`           | ID、deck ID、並び順、connection ID、名前、platform固有のsource JSON                      |
+| `connections`            | ID、platform、接続先origin、外部アカウントIDまたはrelay profile参照、表示名、接続状態    |
+| `connection_credentials` | connection ID、暗号化したアクセストークン、鍵の識別子。通常の接続一覧とは分離            |
+| `oauth_apps`             | インスタンスorigin、callback・scope構成、client ID、暗号化したclient secret              |
+| `oauth_attempts`         | 短時間有効なstate、開始ブラウザとの束縛、接続先、PKCE verifier、期限、一度限りの消費状態 |
+
+単一利用者なので、この段階ではusers/organizations/roles等のテーブルを作らない。
+
+カラムの現行 `profileName` を `connectionId` へ変更する。Twitterはconnectionにrelay profile名を保持し、トークンは引き続きrelay側で管理する。Mastodonは接続インスタンスoriginと `verify_credentials` のaccount IDで重複を判定する。表示handleを主キーにしない。同じインスタンスに別アカウントを追加でき、再接続時には既存のconnection IDを維持する。
+
+DBには秘密を暗号化して保存し、暗号鍵はDB外の実行時credentialファイルから読む。鍵やtokenをNix store・Git・ブラウザ・SSR payload・WebMCPに含めない。DBと鍵の両方が揃って復元できる手順を用意する。
+
+## PR単位のタスク
+
+| ID  | タスク                           | 依存     | 完了条件                                                                                                                                                                               |
+| --- | -------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| T0  | 実行環境とアクセス経路を固定     | なし     | 本番HTTPS origin/callback候補を決め、PC・スマホから同じ利用者として接続。Serve以外からのヘッダー偽装を許さない構成を確認。対象Mastodonのバージョン・OAuthメタデータも調べる            |
+| T1  | SQLiteと永続ディレクトリを導入   | T0       | 現行Node/Nixで動くdriver・migration方式を実証。`StateDirectory`等でDBを永続化。再起動・アプリ更新後も残り、バックアップから復元できる。依存追加時はflakeのpnpm hash更新まで行う        |
+| T2  | connectionモデルへTwitterを移行  | T1       | relay profile一覧から接続を作り、カラム・取得・キャッシュ・ページ送りがconnection IDを使う。2つのTwitter接続を混ぜずに並列表示。不明・削除済みの接続はエラーとして残す                 |
+| T3  | デッキをサーバー保存し端末間共有 | T1,T2    | PCで作ったデッキが別ブラウザコンテキストに表示。revision競合で上書きを拒否。WebMCPも同じ保存処理を使う。既存localStorageからの明示インポートを提供し、重複取り込みと既存DBの破壊を防ぐ |
+| T4  | Mastodon OAuthとトークン保管     | T0,T1,T2 | 接続先登録→認可→callback→本人確認→暗号化保存。同一インスタンス2アカウント・別インスタンス・再接続・解除が動く。拒否/state不一致・期限切れ・再利用を検証                                |
+| T5  | Mastodon取得と投稿正規化         | T4       | ユーザー投稿・リスト・ハッシュタグのカラムを実装し、全文検索を別の能力として扱う。CW・sensitiveメディア・boost・HTML本文を安全に表示。元投稿URLと取得インスタンスのローカルIDを区別    |
+| T6  | 複数接続UIとWebMCPを統合         | T3,T5    | 接続管理から追加・再接続・解除。カラムは接続に応じたsourceを選べる。Twitter/Mastodonを同じデッキに並べ、AIも接続一覧を発見して作成・取得できる                                         |
+| T7  | 2端末・障害・運用の通し検証      | T3,T4,T6 | 端末AのOAuth接続を端末Bで再認可せず利用。編集競合・接続失効・429・再起動・DB復元の検証。UI/API/WebMCP/ログにトークンが出ないことを確認                                                 |
+
+各PRに必要な単体・統合テストを含める。T7までテストを先送りしない。
+
+推奨順序: `T0 → T1 → T2 → T3` で既存Twitterの端末間共有を先に完成。T3とT4は保存モデル確定後に並列作業可能。その後 `T4 → T5 → T6 → T7`。
+
+### T3: 同期の具体的な範囲
+
+- 保存済みデッキはDBを正本にし、クライアントキャッシュへ読み込む。保存中・保存失敗を区別し、サーバーが受理していない編集を「保存済み」と表示しない。
+- デッキ単位のrevisionを比較して、名前・カラム・順序を1トランザクションで更新。同じrevisionへの2回目の更新は競合として返す。
+- 初期案はフォーカス復帰時と表示中の軽い定期再取得。SSE/WebSocket/CRDTは導入しない。編集中の内容は自動更新で消さず、競合時に再読み込みを案内する。
+- 選択中デッキIDは端末ローカル。PCで別デッキを開いたためにスマホの画面まで勝手に切り替わる挙動を避ける。別端末から削除されたデッキを表示中なら、残りのデッキへ移動し通知する。
+- `get_deck`等はrevisionを返し、既存デッキを置換する `set_deck` は期待revisionを指定する。投稿読取ツールにはDB内の秘密を含めない。
+- localStorageインポートは一度限りの移行機能。DB完成後にlocalStorageへ書き戻す二重運用はしない。
+
+### T3/T6: AIが作る一時ビューと保存
+
+- 一時ビューと保存済みデッキは同じカラム定義・描画・接続参照を使う。別のプラットフォーム抽象や投稿取得経路は作らない。
+- AIによる新規作成は既定で一時ビュー。タブ内のメモリで保持し、DBへは書かない。複数の一時ビューを切り替えられ、UIに「一時」と「デッキとして保存」を表示する。再読み込みやタブを閉じると失われることを画面で明示する。
+- 保存操作は新規デッキをサーバーに作成する。成功後にその一時ビューを保存済みデッキへ置き換え、他の端末にも見えるようにする。失敗時は一時ビューを残し、再試行できる。二重クリック・同じ保存要求の再送で重複デッキを作らない。
+- 保存済みデッキから一時コピーを作って、AIが検索語・カラムを組み替えて試せる。元デッキは変更しない。初期実装では保存先は新規デッキとし、元デッキへのマージ機能は作らない。
+- WebMCPは一時ビューの作成・読取・編集・破棄と、明示的な保存を扱う。既存の保存済みデッキ更新には引き続き期待revisionを要求する。ツールの結果は一時か保存済みかを明示し、保存先を推測させない。
+- 一時ビューにも通常のカラム数制限と接続の検証を適用する。投稿内容や認証情報の保存は行わず、保存するのは名前・カラム・検索条件等の定義のみ。
+- 検証: AIの一時作成でDB件数が増えない、ページ送りできる、複数ビューを切り替えられる、保存後は別ブラウザから取得できる、保存失敗で内容を失わない、保存再送が重複しない、一時コピーの編集で元デッキを変更しない。
+
+### T4: OAuthの具体的な範囲
+
+- 初期対象はMastodon 4.3以降を提案。Authorization Code＋PKCE S256とstateを使い、旧版互換の分岐は作らない。Mastodonはconfidential clientを前提にしているためclient secretも必要。[OAuth仕様](https://docs.joinmastodon.org/spec/oauth/)
+- `POST /api/v1/apps`でインスタンスごとに登録。callback・scope構成と合わせて再利用する。[アプリ登録API](https://docs.joinmastodon.org/methods/apps/)
+- 閲覧用scopeに絞る。候補は `read:accounts read:statuses read:lists read:search`。実装したカラムのAPI要件と照合する。同一インスタンスへの別アカウント追加は `force_login=true` を使う。[OAuth API](https://docs.joinmastodon.org/methods/oauth/)
+- state/verifierは開始ブラウザに束縛し、期限付き・一度限りで検証。token交換と `verify_credentials` はサーバーで実施し、戻り先URLにtokenを含めない。[本人確認API](https://docs.joinmastodon.org/methods/accounts/#verify-account-credentials)
+- 接続解除・401からの再接続を実装。通常のMastodon tokenは自動失効しないため、汎用refresh token基盤を先に作らない。[OAuth tokens](https://docs.joinmastodon.org/api/oauth-tokens/)
+- 接続先入力をサーバーがfetchするため、origin・DNS解決先・redirectを検証する。初期は設定したインスタンスの許可リストに限定する案。OAuthやページ送りを家のLANへの汎用HTTP転送にしない。
+
+### T5/T6: プラットフォーム抽象化
+
+- 共通化するのはconnection参照、取得結果、エラー、継続ページの境界。全SNSへTwitterのTop/Latestや検索構文を要求しない。
+- source schemaはplatformとkindで分岐。MastodonのリストID・アカウントIDは接続インスタンスの文脈を持つ。接続変更時はリストを選び直す。
+- 投稿の同一性にはcanonical URIを使い、取得先のローカルstatus IDはAPI操作用に保持する。boostのwrapperと元投稿を区別する。
+- HTML本文は許可する要素・URLを制限して処理。CW・sensitiveを初期表示で尊重し、全文を単に既存のtextへ詰めない。
+- Mastodonの全文検索はインスタンスの検索環境次第。明示的な検索エラーと正常な空レスポンスを区別する。ただし4.5.3では検索バックエンド無効時も空配列を返すため、0件だけで全文検索への対応可否は判定できない。画面にも検索範囲が接続先の設定に依存することを表示する。[検索API](https://docs.joinmastodon.org/methods/search/)、[4.5.3の検索処理](https://github.com/mastodon/mastodon/blob/v4.5.3/app/services/search_service.rb)
+- ホームタイムライン、通知、Streamingは最初のカラムが動いてから別タスク。既存の調査カラムと手動ページ送りを先に完成する。
+
+## Elkから参考にする範囲
+
+調査対象commit: `8a90074fca9f316a0c71f7249b1a31f21829a987`。
+
+- インスタンス別のOAuth app登録・再利用: [server/utils/shared.ts](https://github.com/elk-zone/elk/blob/8a90074fca9f316a0c71f7249b1a31f21829a987/server/utils/shared.ts)
+- 認可URLと複数アカウント追加: [server/api/[server]/login.ts](https://github.com/elk-zone/elk/blob/8a90074fca9f316a0c71f7249b1a31f21829a987/server/api/%5Bserver%5D/login.ts)
+- アカウント本人確認・インスタンスと表示ドメインの区別: [app/composables/users.ts](https://github.com/elk-zone/elk/blob/8a90074fca9f316a0c71f7249b1a31f21829a987/app/composables/users.ts)
+
+ElkはOAuth app情報をサーバーに持つが、ユーザーtokenはcallback URLを経由してブラウザへ渡し、IndexedDBの `elk-users` に保存する。今回のサーバーtoken保管・端末間同期は別実装にする。[callback](https://github.com/elk-zone/elk/blob/8a90074fca9f316a0c71f7249b1a31f21829a987/server/api/%5Bserver%5D/oauth/%5Borigin%5D.ts)、[ユーザー保存](https://github.com/elk-zone/elk/blob/8a90074fca9f316a0c71f7249b1a31f21829a987/app/plugins/0.setup-users.ts)
+
+Elkのグローバルなcurrent accountの切り替えも、そのままカラムごとの並列取得には使わない。各カラムはconnection IDから独立したリクエスト文脈を得る。[Mastodonクライアント](https://github.com/elk-zone/elk/blob/8a90074fca9f316a0c71f7249b1a31f21829a987/app/composables/masto/masto.ts)
+
+## 後続タスク
+
+- Bluesky: 接続・認可方式を別途調査し、MastodonのOAuth仕様を流用しない。
+- Threads: アプリ登録・利用可能な読み取り権限・検索範囲を実機確認してからスコープを決める。
+- Nostr: relay集合・署名/鍵の扱いを別に設計し、OAuthに無理に合わせない。
+- AIサマリー/並列収集: 投稿snapshotと取得日時・クエリ・接続文脈を保存する別のデータモデルを追加する。今回は設定同期のDBに投稿アーカイブを混ぜない。

docs/plans/2026-09-28-shadcn-ui.md

@@ -0,0 +1,58 @@
+# shadcn workspace migration
+
+> Tooling update: Biome has since been replaced by Oxlint for linting (including
+> the shadcn rules) and Oxfmt for formatting. The checks recorded below describe
+> the tooling used at the time of this migration; see README for current commands.
+
+## Target
+
+Replace the custom workspace UI with the Base UI version of shadcn sidebar-09
+at commit 98a1fe67b439324ddc857f47fbdce056600a4329. Preserve its icon rail,
+contextual second sidebar and SidebarInset. Adapt the rail to research chat and
+deck management, keeping the research panel mounted so SSE state remains live.
+On small screens, use the sidebar Sheet and keep all actions reachable.
+
+Use official MessageScroller, Message, Bubble and Marker for the existing Codex
+conversation. Keep transport, history, retry, stop, account selection, Markdown
+and citation navigation. Use shadcn primitives for forms, dialogs, menus and
+post metadata throughout the app. Use Tailwind v4 and shared shadcn semantic
+tokens; remove legacy control styles that override primitives.
+
+Install @shadcn/lint with an executable design-token policy alongside Biome.
+Update README and Nix dependency hash as needed.
+
+## Verification
+
+- Typecheck, Biome, design lint, unit suite, production build, unused-code check.
+- Browser integration suite: decks, source editing, connections, conversation,
+  citation navigation, menus and keyboard focus.
+- Render desktop plus 320/375/414/768 px: rail collapse, mobile Sheet, independent
+  column scrolling, chat composer visibility, no document horizontal overflow.
+- Inspect screenshots and run Axe on relevant states.
+
+## Status
+
+Completed on 2026-09-28.
+
+- SidebarProvider, nested icon/context Sidebars and SidebarInset now implement
+  the referenced sidebar-09 structure; the mobile Sheet keeps its content mounted.
+- Research state and deck-dialog drafts live above the responsive shell. Closing
+  or resizing the sidebar preserves drafts, selected accounts and retry identity.
+- MessageScroller, Message, Bubble/BubbleContent, Marker/MarkerContent, InputGroup
+  and Collapsible replace the chat UI. Markdown list markers and headings remain
+  visible after Tailwind's reset; citation highlighting uses theme tokens.
+- Forms, dialogs, dropdown menus, avatars, badges and empty states use Base UI
+  shadcn components. No backend transport, storage or access contracts changed.
+- @shadcn/lint runs in pnpm lint and rejects raw palette colors. Nix dependency
+  hash and README/deck docs are updated.
+
+Verification: 336 unit tests passed (one explicit live-relay test skipped), all
+56 desktop/mobile E2E tests passed. After the final isolated chat styling fixes,
+all 10 research E2E tests and 22 related unit tests passed again. Typecheck,
+Biome/design lint, Knip, production build and the Nix package build passed.
+Browser checks covered 320/375/414/768px, rendered chat and post screenshots,
+Axe, dialog focus restoration, breakpoint draft preservation and closed-sidebar
+SSE deck updates. Automated browser tests use mock relay/research data.
+A subsequent dev-server smoke check through the Tailscale HTTPS URL confirmed
+the real relay displayed 14 posts across six columns without UI alerts.
+No production deployment was performed.

docs/research-decks.md

@@ -0,0 +1,148 @@
+# Research decks
+
+## Workspace
+
+`/deck` renders the research workspace; `/` is the integrated daily home. A collapsible shadcn/ui
+sidebar based on `sidebar-09` shares its navigation rail with the article reader
+at `/inbox`. Within Research, it switches between research chat and deck management.
+Deck management switches decks and adds columns. The avatar at the bottom of the
+shared sidebar opens connected-account management in a dialog from either workspace.
+Up to six ordered columns scroll independently; only the active deck
+mounts and fetches its columns. On mobile, the sidebar opens as a sheet.
+shadcn Base UI dialogs handle creation and editing, with Escape and focus
+restoration. Column menus offer editing, ordering, and deletion; refresh and
+pagination are manual. The adjacent chat uses MessageScroller, Message, Bubble,
+Marker and InputGroup with the existing research backend.
+
+Twitter and Mastodon can appear together, with different accounts in each
+column. Original-post links open their source site. Separate reader, search,
+list, user-profile, and conversation pages are not provided.
+
+## Definitions and connections
+
+`src/features/decks/model.ts` validates deck IDs, titles, ordered columns, and
+unique column IDs within each deck. Each column contains `id`, `title`,
+`connectionId`, and a platform-specific `source`.
+
+| Platform | Source kind | Conditions                                                              |
+| -------- | ----------- | ----------------------------------------------------------------------- |
+| Twitter  | `search`    | Native `query`, `product` (`Top`/`Latest`), `following`                 |
+| Twitter  | `user`      | `target`: handle or X/Twitter profile URL                               |
+| Twitter  | `list`      | `target`: numeric list ID or X/Twitter list URL                         |
+| Mastodon | `search`    | `query`; results depend on the instance's search configuration          |
+| Mastodon | `user`      | `target`: account handle or the connected instance's numeric account ID |
+| Mastodon | `list`      | `target`: numeric list ID for the connected account                     |
+| Mastodon | `hashtag`   | `target`: tag without `#`, containing letters, numbers, or underscores  |
+
+`connectionId` is the account binding, distinct from a deck's name. Twitter
+connections resolve to profiles discovered from the configured relay.
+Mastodon connections identify accounts by instance origin and remote account
+ID; OAuth tokens stay encrypted on the server. The connection manager supports
+adding, reconnecting, and disconnecting Mastodon accounts. See
+[storage and OAuth](storage-and-oauth.md) for configuration and recovery.
+
+The editor discovers lists for the selected account. Changing accounts clears
+target-based conditions so an instance-local ID is not reused accidentally.
+Searches can retain conditions between accounts on the same platform. There is
+no global account selector or fallback to another account. Missing or
+disconnected bindings produce errors.
+
+The complete source and connection ID form query-cache identity. Equal
+conditions on the same connection share pages; different connections retain
+separate results and cursors. Deck synchronization does not poll post feeds.
+
+## Implementation boundaries
+
+- `column-editor.tsx` owns the title, connection binding, and final submission.
+- `column-source-editor.tsx` dispatches by platform and defines rebinding rules.
+- `twitter-source-editor.tsx` and `mastodon-source-editor.tsx` own each
+  platform's source selection, fields, and account-specific list discovery.
+- `use-research-feed.ts` dispatches requests and keys the cache by connection
+  and source. Server functions resolve credentials and fetch upstream pages.
+- `platforms/types.ts` defines normalized `ResearchPost` and `ResearchPage`
+  records consumed by cards and column tools, without raw provider responses
+  or credentials.
+
+Twitter posts use `twitter:<id>` keys. Mastodon posts use canonical status URIs
+for keys and retain the fetched instance's native status ID separately. Boosts
+keep the wrapper identity and identify the boosting account. Mastodon HTML is
+sanitized on the server; cards honor content warnings and sensitive media.
+
+## Saved decks and temporary views
+
+SQLite is authoritative for saved definitions. Creating a named deck through
+the UI saves it; subsequent saved-deck edits and deletions use a revision check
+in a transaction. A stale revision is rejected. Save failures remain visible
+and do not report unsaved edits as persisted.
+
+Saved decks refresh on focus and every five seconds while visible. Refresh is
+held while an editor is open. The `deck` URL parameter selects the active view;
+selecting a deck does not switch another device's view. Browser history restores
+selection, and saved decks can be opened from a copied URL. Deleting the active deck selects a remaining one. When none remain, the
+app opens an empty temporary view.
+
+WebMCP-created views are temporary by default. Temporary copies of saved decks
+also remain in this tab's memory. Editing them does not write to SQLite. The
+explicit save action replaces a temporary view with a shared saved deck,
+preserving its ID for idempotent retries. Failed saves retain temporary
+content. Temporary views disappear on reload or navigation, including OAuth
+redirects. Only definitions are saved: posts, cursors, and scroll positions
+are not archived.
+
+Research chats separately retain the agent-generated deck and last supplied
+deck context. Reopening a saved chat reconstructs a temporary view, including
+on another device or after a server restart. Chat citations retain a limited
+post projection for source navigation; this does not persist the deck's feed
+cache, pagination cursors, scroll positions or unsent manual edits.
+
+The UI offers an explicit, one-time import of valid version-2 data from
+`twitter-lite-research-deck` in localStorage. It resolves old relay profile
+names to connection IDs and creates new saved deck IDs transactionally. A
+server marker prevents repeated imports; different content after the first
+import is rejected. The browser copy is removed only after success. Invalid
+or unsupported data is left untouched. HTTP and HTTPS have separate browser
+storage, but authorized devices read the same server-backed decks.
+
+## WebMCP
+
+Use `list_connections` to discover bindings, then `set_deck` to create a
+temporary view. This example uses IDs returned by discovery:
+
+```json
+{
+  "title": "WebMCPの反応",
+  "columns": [
+    {
+      "title": "Twitter",
+      "connectionId": "twitter-connection-id",
+      "source": { "platform": "twitter", "kind": "search", "query": "WebMCP lang:ja" }
+    },
+    {
+      "title": "Mastodon",
+      "connectionId": "mastodon-connection-id",
+      "source": { "platform": "mastodon", "kind": "hashtag", "target": "WebMCP" }
+    }
+  ]
+}
+```
+
+Read the returned deck ID and call `save_deck` only when the view should be
+shared. Replacing a saved deck requires its `deckId` and `expectedRevision`;
+include every column to retain. Post loading is asynchronous and can fail
+independently of saving. See [all tool contracts](webmcp-prototype.md).
+
+## Verification
+
+Unit tests exercise source normalization, account-specific caches, OAuth,
+credential storage, revisions, import, and temporary-view behavior. Playwright
+uses an isolated SQLite database and mock relay through real server functions
+to exercise shared decks across browser contexts, editing, persistence,
+pagination, and native WebMCP. Deterministic automated tests do not require
+live SNS credentials.
+
+## Conversation execution
+
+The [research runtime](research-runtime.md) uses AI SDK and the Codex app-server
+provider. Conversations are selected by URL, with per-conversation background
+execution and reconnectable SSE. Opening New chat or another saved conversation
+does not stop an existing turn or change another browser's selection.

docs/research-runtime.md

@@ -0,0 +1,54 @@
+# Research runtime
+
+Research uses Vercel AI SDK 7 `streamText` with
+`ai-sdk-provider-codex-cli` 2.3's app-server provider. The provider owns its local
+stdio child, thread resumption, protocol decoding, and abort handling. The app
+owns accepted requests, account-scoped tools, snapshots, and report validation.
+The separate WebSocket launcher is removed.
+
+## Tools
+
+The provider does not register AI SDK `tools` as Codex dynamic tools. Existing
+research definitions and executors are exposed with `createSdkMcpServer` instead.
+Validation, connected-account scope, request budgets, evidence tracking, and
+read-only SNS behavior remain in `agent-tools.server.ts`. Provider execution is
+one agent turn; there is no second AI SDK tool loop replaying those calls.
+Resumed threads that already registered dynamic tools route their calls through
+`onDynamicToolCall` to the same validated executor.
+
+## Lifecycle and selection
+
+The background runner is keyed by conversation ID. Acceptance saves the user
+message before starting the model. A request ID identifies a new conversation
+and deduplicates retries within the process. Overlapping turns of the same
+conversation are rejected, while different conversations can run independently.
+
+The URL selects a conversation. GET status and SSE subscribe to that ID;
+selecting history never starts or cancels a turn. Reconnection sends the latest
+complete snapshot. Closing a browser or changing its URL only detaches a viewer.
+Only Stop, the execution timeout, or a server-side failure aborts generation.
+Authentication expiry or logout closes the viewer's stream.
+
+SQLite retains messages, thread IDs, generated decks, and citations. It no
+longer stores a global active conversation pointer. Browser views cannot change
+another browser's selection. After a backend restart, unfinished conversations
+are marked interrupted and require an explicit follow-up. No turn is replayed
+automatically. Reports remain files under the configured report root.
+
+## Streaming presentation
+
+The model stream uses `smoothStream` with 15 ms pacing and the supplied chunking
+pattern `/[\u3040-\u309F\u30A0-\u30FF]|\S+\s+/`. The trailing buffer flushes at the
+text-end event. The existing snapshot SSE remains the UI's reconnectable data
+channel; an HTTP request's lifetime never owns the model execution.
+
+Streamdown displays partial Markdown and animates only the latest live answer.
+Completed messages render immediately. Reduced-motion preferences disable the
+animation. HTML is skipped, unsafe link protocols are rejected, images remain
+links, and retrieved post citations keep their deck navigation behavior.
+`@shadcn/helpers/ai-sdk` provides deterministic streaming fixtures for UI tests.
+
+References: [Codex provider](https://github.com/ben-vargas/ai-sdk-provider-codex-cli),
+[AI SDK smoothing](https://ai-sdk.dev/docs/reference/ai-sdk-core/smooth-stream),
+[Streamdown animation](https://streamdown.ai/docs/animation),
+[shadcn AI SDK helpers](https://ui.shadcn.com/docs/helpers/ai-sdk).

docs/storage-and-oauth.md

@@ -0,0 +1,103 @@
+# Shared storage and Mastodon OAuth
+
+Personal Workspace runs as a single personal server behind Tailscale Serve. The
+backend binds to loopback. The configured Tailscale identity is an outer access
+check; a separate [owner login](login.md) is required in every deployment mode.
+Browser requests that change state must have the configured Origin. OAuth
+callbacks also pass the owner check; the browser must be able to reach the
+tailnet HTTPS address after Mastodon authorization.
+
+## Runtime configuration
+
+| Variable                           | Value                                                     |
+| ---------------------------------- | --------------------------------------------------------- |
+| `TWITTER_LITE_ORIGIN`              | Exact Serve HTTPS origin, without a trailing slash        |
+| `TWITTER_LITE_ALLOWED_LOGIN`       | Owner's Tailscale login                                   |
+| `TWITTER_LITE_DB_PATH`             | Absolute path to the SQLite database on local disk        |
+| `TWITTER_LITE_MASTODON_ORIGINS`    | Comma-separated approved HTTPS instance origins           |
+| `TWITTER_LITE_CREDENTIAL_KEY_FILE` | Runtime file containing 32 random bytes encoded as base64 |
+
+The credential key is required for Mastodon, but not for Twitter-only use.
+Generate it once, keep it outside Git and the Nix store, and retain it when
+updating the application. For example, with an existing private directory:
+
+```sh
+umask 077
+nix develop -c node --input-type=module -e 'import {randomBytes} from "node:crypto"; import {writeFileSync} from "node:fs"; writeFileSync("/absolute/private/credential-key", randomBytes(32).toString("base64") + "\n", {flag: "wx", mode: 0o600})'
+```
+
+The command refuses to replace an existing file. Losing the key makes saved
+SNS credentials unreadable. A separate protected backup of the key is needed
+alongside database backups.
+
+## Database and migrations
+
+Drizzle ORM 0.45.3, Drizzle Kit 0.31.11 and better-sqlite3 13.0.3 are pinned.
+The driver ships native prebuilds; dependency install scripts remain disabled.
+Both the actual Nix Node runtime and the built Nix package have been exercised
+with SQLite operations and the packaged backup command.
+
+`drizzle/` contains generated SQL and metadata. `pnpm db:generate` generates
+SQL and bundles it into TypeScript for the server. Commit both artifacts with
+schema changes. The server applies pending migrations under an immediate
+transaction before serving an authorized application request. It enables WAL,
+foreign keys and a five-second busy timeout. Deployment does not depend on a
+particular working directory or a separate migration command.
+
+Deck definitions, ordered columns, connection metadata, OAuth applications
+and short-lived OAuth attempts live in SQLite. Tokens, client secrets and
+PKCE verifiers are authenticated encrypted envelopes in separate fields.
+Their associated data binds each secret to its record and purpose. Public
+connection responses never select those fields.
+
+## Backups and restore
+
+Use the live SQLite backup API instead of copying only the main file while WAL
+is active. The destination must be an absolute path that does not already
+exist; backups are mode 0600 and pass a SQLite integrity check.
+
+```sh
+TWITTER_LITE_DB_PATH=/absolute/workspace.sqlite \
+  nix develop -c pnpm db:backup /absolute/backups/workspace-2026-09-24.sqlite
+```
+
+The Nix package exposes the same operation as `twitter-lite-backup`:
+
+```sh
+TWITTER_LITE_DB_PATH=/var/lib/twitter-lite/workspace.sqlite \
+  twitter-lite-backup /absolute/backups/workspace-2026-09-24.sqlite
+```
+
+Run it as an identity that can read the database and write the backup directory.
+On NixOS the application uses `DynamicUser`, `StateDirectory=twitter-lite` and
+mode 0700. The runtime key is passed with systemd `LoadCredential`.
+
+For restore, stop the service first. Preserve the current state directory as
+a separate recovery copy, then restore the verified backup as
+`workspace.sqlite` in a clean state directory with the service's ownership and
+permissions. Do not leave old `-wal` or `-shm` sidecars beside a restored main
+database. Restore the matching credential key separately, then start the
+service and verify decks and account access. Do not attempt to restore a newer
+schema into an older application version.
+
+## OAuth and instance support
+
+Initial support targets Mastodon 4.3+ with PKCE S256. The first configured
+instance, `https://fedi.yutakobayashi.com`, reported 4.5.3 and S256 on 2026-09-24.
+Only configured HTTPS origins with public DNS addresses are accepted; server
+requests pin the resolved address and refuse redirects.
+
+Each instance/callback/scope combination has an OAuth application. Authorization
+uses `read:accounts read:statuses read:lists read:search`, PKCE, a ten-minute
+one-use state and an HttpOnly browser-binding cookie. Tokens are exchanged and
+account identity is verified on the server. The callback URL never contains an
+access token. Same-instance accounts remain separate; reconnecting preserves
+the connection ID only for the same account.
+
+An expired token marks its connection unavailable until reconnected. Disconnect
+first revokes the token using the original OAuth application, then removes the
+local credential while retaining the connection reference used by saved decks.
+
+Search results depend on the instance's backend and indexing. A successful
+empty response does not prove full-text search is enabled: Mastodon 4.5.3 also
+returns empty status results when its search backend is disabled.

docs/superpowers/specs/2026-07-13-tweet-detail-thread-design.md

@@ -89,14 +89,14 @@ The server input has two valid states:
 
 ```ts
 type InitialThreadInput = {
-  tweetId: string
-}
+  tweetId: string;
+};
 
 type ContinuedThreadInput = {
-  tweetId: string
-  conversationId: string
-  cursor: string
-}
+  tweetId: string;
+  conversationId: string;
+  cursor: string;
+};
 ```
 
 All IDs must be decimal strings. Cursor values are opaque non-empty strings.
@@ -106,11 +106,11 @@ The successful page shape is:
 
 ```ts
 type ThreadPage = {
-  tweets: Post[]
-  focalPost?: Post
-  conversationId: string
-  nextCursor?: string
-}
+  tweets: Post[];
+  focalPost?: Post;
+  conversationId: string;
+  nextCursor?: string;
+};
 ```
 
 `focalPost` is present only on the initial page. All returned posts pass through
@@ -137,7 +137,7 @@ cannot rediscover the conversation root if the cursor page omits that reply.
 
 1. Validate the supplied `tweetId`, `conversationId`, and cursor.
 2. Call `getThreadPaged(conversationId, {
-   cursor, maxPages: 1, pageDelayMs: 0 })` once.
+cursor, maxPages: 1, pageDelayMs: 0 })` once.
 3. Return the sanitized tweets with the same conversation ID and new cursor.
 
 The original `tweetId` remains part of the query identity and validation
@@ -149,7 +149,10 @@ continuation requests.
 Extend the existing feed request union with:
 
 ```ts
-{ kind: 'thread'; tweetId: string }
+{
+  kind: "thread";
+  tweetId: string;
+}
 ```
 
 The thread query key includes the focal tweet ID. Its initial page parameter is

docs/superpowers/specs/2026-07-13-twitter-lite-design.md

@@ -68,16 +68,16 @@ Work spans two repositories and the Gitea package registry:
 Bird currently hard-codes `product: 'Latest'` in SearchTimeline requests. Add the following public contract:
 
 ```ts
-export type SearchProduct = 'Top' | 'Latest'
+export type SearchProduct = "Top" | "Latest";
 
 export interface SearchFetchOptions {
-  includeRaw?: boolean
-  product?: SearchProduct
+  includeRaw?: boolean;
+  product?: SearchProduct;
 }
 
 export interface SearchPaginationOptions extends SearchFetchOptions {
-  maxPages?: number
-  cursor?: string
+  maxPages?: number;
+  cursor?: string;
 }
 ```
 
@@ -126,7 +126,7 @@ new TwitterClient({
   relayBaseUrl: process.env.TWITTER_RELAY_BASE_URL,
   profileName: process.env.BIRD_PROFILE_NAME,
   timeoutMs: 20_000,
-})
+});
 ```
 
 `TWITTER_RELAY_BASE_URL` is required. `BIRD_PROFILE_NAME` is optional but must be passed explicitly because the Bird library does not read that environment variable itself.
@@ -175,10 +175,14 @@ None of these functions exposes the Bird client, arbitrary method names, arbitra
 
 ### Search Flow
 
-1. Trim and validate the raw query.
-2. Append `filter:follows` when the following toggle is enabled and the operator is not already present.
-3. Fetch one page with `getAllSearchResults(query, { product, cursor, maxPages: 1 })`.
-4. Return normalized tweets and the next cursor.
+1. Keep the raw query and structured author, period, language, content, and
+   exclusion controls in typed URL search parameters.
+2. Compile selected controls into a deterministic advanced search expression
+   using `from:`, `since:`, `until:`, `lang:`, and `filter:` operators.
+3. Trim and validate the compiled query, including its 512-character limit.
+4. Append `filter:follows` when the following toggle is enabled and the operator is not already present.
+5. Fetch one page with `getAllSearchResults(query, { product, cursor, maxPages: 1 })`.
+6. Return normalized tweets and the next cursor.
 
 Advanced X search grammar remains available because the raw query is otherwise passed unchanged.
 
@@ -207,7 +211,11 @@ The selected layout is **Focused Tabs**:
 - no content on first load;
 - results directly below the submitted controls.
 
-The User tab contains one target input and a Display button. The Search tab contains a query input, a Popular/Latest segmented control, a Following only checkbox, and a Search button.
+The User tab contains one target input and a Display button. The Search tab
+contains a query input; buttons that open inline author, period, language,
+content-type, and exclusion controls; removable active-condition chips; a
+collapsible compiled-query preview; a Popular/Latest segmented control; a
+Following only checkbox; and a Search button.
 
 Submitting a user target normalizes it to a handle and navigates to `/:handle`.
 Submitting a search updates the route's typed search parameters. Changing tabs
@@ -344,7 +352,9 @@ The work is complete when:
    target or query, following a post detail link, or manually opening a valid
    status URL.
 3. A valid handle or profile URL loads that user's posts.
-4. Search supports Top, Latest, and the follows filter.
+4. Search supports Top, Latest, the follows filter, and button-driven author,
+   period, language, content-type, reply, and repost conditions while preserving
+   raw advanced search syntax.
 5. Infinite scrolling continues cursor pages without a fixed limit and without duplicate posts.
 6. Relay credentials and Bird remain server-only.
 7. No excluded discovery or mutation feature is reachable.

docs/vitals-preview.md

@@ -0,0 +1,22 @@
+# Vitals reference preview
+
+`/vitals` recreates the Body and Environment screenshots attached to
+[Alan Shiflett’s post](https://x.com/AlanShiflett/status/2103524300158366183).
+The shared sidebar opens it as Vitals. Body categories and history, environment
+metric details, chart period/series selection, and simulated climate controls
+are interactive. Other screenshot navigation entries open a preview explanation.
+
+All scores, classifications, dates, readings, and connection indicators are
+reference/demo values, not the user's health or device data. No clinical
+assessment, data sync, or device command is performed. Obscured reference text
+remains a visual placeholder, not inferred medical content.
+
+`public/vitals/body-reference.jpg` is the post's second public image, retained
+as the anatomy illustration source and clipped in CSS. Source media:
+https://pbs.twimg.com/media/HTE4JWFWUAAnPBt.jpg
+The rest of the interface is HTML/CSS with SVG data charts. Reference-specific
+colors are scoped to `--vital-*` tokens in `vitals.css`.
+
+Sections, tabs, history, chart filters, and detail dialogs are URL state and
+restore on reload or browser Back/Forward. Simulated climate control values
+remain local; opening a URL never issues a device command.

docs/webmcp-prototype.md

@@ -0,0 +1,126 @@
+# WebMCP prototype
+
+## Registration
+
+The deck workspace exposes nine React-owned tools on `/` and `/deck`.
+`usewebmcp` handles native browser registration and cleanup. Tools become
+available after saved decks load. Connection discovery may still be pending;
+`list_connections` then returns `connections: null`.
+
+Registration uses `document.modelContext`; there is no polyfill or external
+MCP transport. Unsupported browsers retain the manual interface. All server
+operations use the same access controls and persistence rules as the UI.
+
+## Workspace tools
+
+| Tool               | Input                                                                    | Behavior                                                                                             |
+| ------------------ | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
+| `list_connections` | `{}`                                                                     | Return connection IDs, platforms, origins, account IDs, display names, and states; never credentials |
+| `list_decks`       | `{}`                                                                     | Return saved decks and this tab's temporary views, `activeDeckId`, and `storageError`                |
+| `get_deck`         | Optional `deckId`                                                        | Read the named or active view, including `persisted` and saved `revision`                            |
+| `set_deck`         | Optional `deckId` and `expectedRevision`, required `title` and `columns` | Without an ID, create a temporary view; with an ID, replace and activate that existing view          |
+| `save_deck`        | `deckId`                                                                 | Explicitly persist a temporary view; an already saved deck is unchanged                              |
+| `select_deck`      | `deckId`                                                                 | Activate a view and update the URL; other tabs remain unchanged                                      |
+| `delete_deck`      | `deckId`, optional `expectedRevision`                                    | Discard a temporary view or delete a saved deck for all devices                                      |
+
+Read tools return the workspace's current client snapshot, not a fresh server
+request. Saved definitions refresh on focus and while visible, except during
+editing. Replacing or deleting a saved deck requires `expectedRevision` from
+the definition being edited. A stale revision fails without overwriting the
+server. Use the UI's reload action after a conflict when a fresh definition
+is needed.
+
+`set_deck` accepts at most six columns, each with a title, `connectionId` from
+discovery, and a source. Connections must be connected and match the source
+platform. Optional column IDs preserve identity; omitted IDs are generated.
+Include every retained column: omitted columns are removed, and an empty array
+clears the view. A supplied deck ID must already exist.
+
+Twitter sources support `search`, `user`, and `list`. `platform` defaults to
+`twitter`; search requires `query` and defaults `product` to `Latest` and
+`following` to false. User/list targets accept handles or profile URLs and
+numeric list IDs or list URLs, respectively.
+
+Mastodon requires `platform: "mastodon"` and supports `search` (`query`),
+`user` (handle or instance-local account ID), `list` (account-local numeric
+list ID), and `hashtag` (tag without `#`). It does not accept Twitter ranking
+or following controls. Search availability and coverage depend on the
+instance; an empty successful result does not prove full-text support.
+
+## Mutation results and persistence
+
+`set_deck` returns `deck`, its actual `persisted` flag, and
+`posts: "loading-asynchronously"`. A new view exists only in tab memory until
+`save_deck` succeeds. Temporary views disappear on reload or navigation,
+including OAuth redirects. Saving keeps the ID, allowing an identical create
+request to be retried without duplicate decks. Failed saves keep temporary
+content; rejected updates do not replace the accepted saved definition.
+
+Successful mutations close unsaved editor forms. Deleting the active view
+selects a remaining one; deleting the last opens an empty temporary view.
+There is no tool-level deletion undo. Column requests may fail independently
+after a definition is applied or saved. Existing browser decks are imported
+only through the explicit UI import action, not through a tool side effect.
+
+## Column tools
+
+`get_column_posts` accepts `columnId`, `offset` (default 0, nonnegative integer),
+and `limit` (default 20, integer 1–50). It reads already loaded posts without a
+network request. Only columns mounted in the active view are available;
+select the view and allow it to render first.
+
+`load_more_column` accepts `columnId` and fetches or retries one continuation
+using the column's connection. Wait for initial loading or refresh to finish.
+Concurrent pagination joins the existing request. If the view or column
+changes during pagination, execution fails rather than returning results under
+the changed identity. At the end, no posts are appended and `hasMore` is false.
+
+Both return:
+
+- `column`: ID, title, connection ID, and source
+- `status`: `loading`, `ready`, or `error`, with `loading` and `error` details
+- `posts`: normalized records with original URLs, text, author, and available
+  media, quotes, content warnings, or boost information
+- `loadedCount`, `offset`, and `nextOffset` for slices of deduplicated posts
+- `hasMore`: whether the feed has an upstream continuation
+
+Continuation returns up to 20 newly appended posts. Use `nextOffset` with
+`get_column_posts` for additional already loaded records; use
+`load_more_column` for another upstream page. These are cache snapshots, not
+archived evidence.
+
+## Errors and annotations
+
+Results are JSON in an MCP text content block. Execution failures set
+`isError: true` with `code`, `message`, and `retryable: false`. Schema and
+connection-validation failures use `invalid-input`; other execution failures
+use `tool-error`. Column snapshots expose upstream errors separately in their
+`error` field. Empty successful queries are not errors.
+
+`list_connections`, `list_decks`, `get_deck`, and `get_column_posts` have
+`readOnlyHint: true`. `delete_deck` has `destructiveHint: true`; tools returning
+external posts mark them untrusted. Annotations describe behavior and do not
+grant authorization. No tool posts to or modifies an SNS account.
+
+## Browser setup and verification
+
+```sh
+nix develop -c pnpm test
+nix develop -c pnpm typecheck
+nix develop -c pnpm test:e2e e2e/integrations/webmcp.test.ts
+```
+
+E2E tests enable Chromium WebMCP/testing flags and invoke actual registered
+tools through `navigator.modelContextTesting`. Mock relay responses pass
+through real server functions and isolated database state.
+
+For interactive testing, enable `chrome://flags/#enable-webmcp-testing`,
+restart Chrome, and use Model Context Tool Inspector. Reload after changing
+browser support. Native WebMCP requires a secure context; use the configured
+Tailscale Serve HTTPS origin for remote access. Development also requires
+allowing its exact hostname through `__VITE_ADDITIONAL_SERVER_ALLOWED_HOSTS`.
+The app's owner check still applies; direct localhost access does not supply
+Serve identity. See [runtime access configuration](storage-and-oauth.md).
+
+No production origin-trial token or external MCP-client bridge is configured.
+Browser cancellation does not guarantee cancellation of a shared feed request.

drizzle.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/features/storage/schema.ts",
+  out: "./drizzle",
+});

drizzle/0000_aspiring_bloodstorm.sql

@@ -0,0 +1,66 @@
+CREATE TABLE `connection_credentials` (
+	`connection_id` text PRIMARY KEY NOT NULL,
+	`encrypted_token` text NOT NULL,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`connection_id`) REFERENCES `connections`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE TABLE `connections` (
+	`id` text PRIMARY KEY NOT NULL,
+	`platform` text NOT NULL,
+	`origin` text NOT NULL,
+	`account_id` text,
+	`relay_profile` text,
+	`display_name` text NOT NULL,
+	`status` text NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `connections_account` ON `connections` (`platform`,`origin`,`account_id`);--> statement-breakpoint
+CREATE UNIQUE INDEX `connections_relay_profile` ON `connections` (`origin`,`relay_profile`);--> statement-breakpoint
+CREATE TABLE `deck_columns` (
+	`id` text NOT NULL,
+	`deck_id` text NOT NULL,
+	`position` integer NOT NULL,
+	`connection_id` text NOT NULL,
+	`title` text NOT NULL,
+	`source` text NOT NULL,
+	PRIMARY KEY(`deck_id`, `id`),
+	FOREIGN KEY (`deck_id`) REFERENCES `decks`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`connection_id`) REFERENCES `connections`(`id`) ON UPDATE no action ON DELETE restrict,
+	CONSTRAINT "deck_columns_valid_position" CHECK("deck_columns"."position" >= 0)
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `deck_columns_position` ON `deck_columns` (`deck_id`,`position`);--> statement-breakpoint
+CREATE TABLE `decks` (
+	`id` text PRIMARY KEY NOT NULL,
+	`title` text NOT NULL,
+	`revision` integer DEFAULT 1 NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	CONSTRAINT "decks_positive_revision" CHECK("decks"."revision" >= 1)
+);
+--> statement-breakpoint
+CREATE TABLE `oauth_apps` (
+	`id` text PRIMARY KEY NOT NULL,
+	`origin` text NOT NULL,
+	`redirect_uri` text NOT NULL,
+	`scopes` text NOT NULL,
+	`client_id` text NOT NULL,
+	`encrypted_client_secret` text NOT NULL,
+	`created_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `oauth_apps_configuration` ON `oauth_apps` (`origin`,`redirect_uri`,`scopes`);--> statement-breakpoint
+CREATE TABLE `oauth_attempts` (
+	`state_hash` text PRIMARY KEY NOT NULL,
+	`browser_hash` text NOT NULL,
+	`app_id` text NOT NULL,
+	`encrypted_verifier` text NOT NULL,
+	`connection_id` text,
+	`expires_at` integer NOT NULL,
+	`consumed_at` integer,
+	FOREIGN KEY (`app_id`) REFERENCES `oauth_apps`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`connection_id`) REFERENCES `connections`(`id`) ON UPDATE no action ON DELETE cascade
+);

drizzle/0001_many_fat_cobra.sql

@@ -0,0 +1 @@
+ALTER TABLE `connection_credentials` ADD `app_id` text REFERENCES oauth_apps(id);

drizzle/0002_fine_master_chief.sql

@@ -0,0 +1,6 @@
+CREATE TABLE `legacy_imports` (
+	`id` text PRIMARY KEY NOT NULL,
+	`payload_hash` text NOT NULL,
+	`deck_ids` text NOT NULL,
+	`created_at` integer NOT NULL
+);

drizzle/0003_romantic_scrambler.sql

@@ -0,0 +1,14 @@
+CREATE TABLE `research_sessions` (
+	`id` text PRIMARY KEY NOT NULL,
+	`title` text NOT NULL,
+	`status` text NOT NULL,
+	`updated_at` integer NOT NULL,
+	`snapshot` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `research_state` (
+	`id` integer PRIMARY KEY NOT NULL,
+	`active_session_id` text,
+	FOREIGN KEY (`active_session_id`) REFERENCES `research_sessions`(`id`) ON UPDATE no action ON DELETE set null,
+	CONSTRAINT "research_state_singleton" CHECK("research_state"."id" = 1)
+);

drizzle/0004_good_natasha_romanoff.sql

@@ -0,0 +1,23 @@
+CREATE TABLE `auth_sessions` (
+	`token_hash` text PRIMARY KEY NOT NULL,
+	`owner_id` integer NOT NULL,
+	`expires_at` integer NOT NULL,
+	FOREIGN KEY (`owner_id`) REFERENCES `workspace_owner`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE TABLE `auth_throttle` (
+	`id` integer PRIMARY KEY NOT NULL,
+	`attempts` integer NOT NULL,
+	`reset_at` integer NOT NULL,
+	CONSTRAINT "auth_throttle_singleton" CHECK("auth_throttle"."id" = 1)
+);
+--> statement-breakpoint
+CREATE TABLE `workspace_owner` (
+	`id` integer PRIMARY KEY NOT NULL,
+	`email` text NOT NULL,
+	`name` text NOT NULL,
+	`password_hash` text NOT NULL,
+	`onboarding_completed_at` integer,
+	`created_at` integer NOT NULL,
+	CONSTRAINT "workspace_owner_singleton" CHECK("workspace_owner"."id" = 1)
+);

drizzle/0005_salty_madripoor.sql

@@ -0,0 +1 @@
+DROP TABLE `research_state`;

drizzle/meta/0000_snapshot.json

@@ -0,0 +1,424 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "42951f9a-6025-4e73-9155-764d25514ba8",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "connection_credentials": {
+      "name": "connection_credentials",
+      "columns": {
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_token": {
+          "name": "encrypted_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "connection_credentials_connection_id_connections_id_fk": {
+          "name": "connection_credentials_connection_id_connections_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "connections": {
+      "name": "connections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "relay_profile": {
+          "name": "relay_profile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "connections_account": {
+          "name": "connections_account",
+          "columns": ["platform", "origin", "account_id"],
+          "isUnique": true
+        },
+        "connections_relay_profile": {
+          "name": "connections_relay_profile",
+          "columns": ["origin", "relay_profile"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "deck_columns": {
+      "name": "deck_columns",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_id": {
+          "name": "deck_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "deck_columns_position": {
+          "name": "deck_columns_position",
+          "columns": ["deck_id", "position"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "deck_columns_deck_id_decks_id_fk": {
+          "name": "deck_columns_deck_id_decks_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "decks",
+          "columnsFrom": ["deck_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deck_columns_connection_id_connections_id_fk": {
+          "name": "deck_columns_connection_id_connections_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "deck_columns_deck_id_id_pk": {
+          "columns": ["deck_id", "id"],
+          "name": "deck_columns_deck_id_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "deck_columns_valid_position": {
+          "name": "deck_columns_valid_position",
+          "value": "\"deck_columns\".\"position\" >= 0"
+        }
+      }
+    },
+    "decks": {
+      "name": "decks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "decks_positive_revision": {
+          "name": "decks_positive_revision",
+          "value": "\"decks\".\"revision\" >= 1"
+        }
+      }
+    },
+    "oauth_apps": {
+      "name": "oauth_apps",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_client_secret": {
+          "name": "encrypted_client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "oauth_apps_configuration": {
+          "name": "oauth_apps_configuration",
+          "columns": ["origin", "redirect_uri", "scopes"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_attempts": {
+      "name": "oauth_attempts",
+      "columns": {
+        "state_hash": {
+          "name": "state_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "browser_hash": {
+          "name": "browser_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_verifier": {
+          "name": "encrypted_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "consumed_at": {
+          "name": "consumed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "oauth_attempts_app_id_oauth_apps_id_fk": {
+          "name": "oauth_attempts_app_id_oauth_apps_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oauth_attempts_connection_id_connections_id_fk": {
+          "name": "oauth_attempts_connection_id_connections_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

drizzle/meta/0001_snapshot.json

@@ -0,0 +1,440 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "1455820b-8aec-4fcb-9790-c7d9f1fd908c",
+  "prevId": "42951f9a-6025-4e73-9155-764d25514ba8",
+  "tables": {
+    "connection_credentials": {
+      "name": "connection_credentials",
+      "columns": {
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_token": {
+          "name": "encrypted_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "connection_credentials_connection_id_connections_id_fk": {
+          "name": "connection_credentials_connection_id_connections_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "connection_credentials_app_id_oauth_apps_id_fk": {
+          "name": "connection_credentials_app_id_oauth_apps_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "connections": {
+      "name": "connections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "relay_profile": {
+          "name": "relay_profile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "connections_account": {
+          "name": "connections_account",
+          "columns": ["platform", "origin", "account_id"],
+          "isUnique": true
+        },
+        "connections_relay_profile": {
+          "name": "connections_relay_profile",
+          "columns": ["origin", "relay_profile"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "deck_columns": {
+      "name": "deck_columns",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_id": {
+          "name": "deck_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "deck_columns_position": {
+          "name": "deck_columns_position",
+          "columns": ["deck_id", "position"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "deck_columns_deck_id_decks_id_fk": {
+          "name": "deck_columns_deck_id_decks_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "decks",
+          "columnsFrom": ["deck_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deck_columns_connection_id_connections_id_fk": {
+          "name": "deck_columns_connection_id_connections_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "deck_columns_deck_id_id_pk": {
+          "columns": ["deck_id", "id"],
+          "name": "deck_columns_deck_id_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "deck_columns_valid_position": {
+          "name": "deck_columns_valid_position",
+          "value": "\"deck_columns\".\"position\" >= 0"
+        }
+      }
+    },
+    "decks": {
+      "name": "decks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "decks_positive_revision": {
+          "name": "decks_positive_revision",
+          "value": "\"decks\".\"revision\" >= 1"
+        }
+      }
+    },
+    "oauth_apps": {
+      "name": "oauth_apps",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_client_secret": {
+          "name": "encrypted_client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "oauth_apps_configuration": {
+          "name": "oauth_apps_configuration",
+          "columns": ["origin", "redirect_uri", "scopes"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_attempts": {
+      "name": "oauth_attempts",
+      "columns": {
+        "state_hash": {
+          "name": "state_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "browser_hash": {
+          "name": "browser_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_verifier": {
+          "name": "encrypted_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "consumed_at": {
+          "name": "consumed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "oauth_attempts_app_id_oauth_apps_id_fk": {
+          "name": "oauth_attempts_app_id_oauth_apps_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oauth_attempts_connection_id_connections_id_fk": {
+          "name": "oauth_attempts_connection_id_connections_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

drizzle/meta/0002_snapshot.json

@@ -0,0 +1,478 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "ebfb67e2-a014-4d40-89e3-30c9b55cf047",
+  "prevId": "1455820b-8aec-4fcb-9790-c7d9f1fd908c",
+  "tables": {
+    "connection_credentials": {
+      "name": "connection_credentials",
+      "columns": {
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_token": {
+          "name": "encrypted_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "connection_credentials_connection_id_connections_id_fk": {
+          "name": "connection_credentials_connection_id_connections_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "connection_credentials_app_id_oauth_apps_id_fk": {
+          "name": "connection_credentials_app_id_oauth_apps_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "connections": {
+      "name": "connections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "relay_profile": {
+          "name": "relay_profile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "connections_account": {
+          "name": "connections_account",
+          "columns": ["platform", "origin", "account_id"],
+          "isUnique": true
+        },
+        "connections_relay_profile": {
+          "name": "connections_relay_profile",
+          "columns": ["origin", "relay_profile"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "deck_columns": {
+      "name": "deck_columns",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_id": {
+          "name": "deck_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "deck_columns_position": {
+          "name": "deck_columns_position",
+          "columns": ["deck_id", "position"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "deck_columns_deck_id_decks_id_fk": {
+          "name": "deck_columns_deck_id_decks_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "decks",
+          "columnsFrom": ["deck_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deck_columns_connection_id_connections_id_fk": {
+          "name": "deck_columns_connection_id_connections_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "deck_columns_deck_id_id_pk": {
+          "columns": ["deck_id", "id"],
+          "name": "deck_columns_deck_id_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "deck_columns_valid_position": {
+          "name": "deck_columns_valid_position",
+          "value": "\"deck_columns\".\"position\" >= 0"
+        }
+      }
+    },
+    "decks": {
+      "name": "decks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "decks_positive_revision": {
+          "name": "decks_positive_revision",
+          "value": "\"decks\".\"revision\" >= 1"
+        }
+      }
+    },
+    "legacy_imports": {
+      "name": "legacy_imports",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_hash": {
+          "name": "payload_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_ids": {
+          "name": "deck_ids",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_apps": {
+      "name": "oauth_apps",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_client_secret": {
+          "name": "encrypted_client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "oauth_apps_configuration": {
+          "name": "oauth_apps_configuration",
+          "columns": ["origin", "redirect_uri", "scopes"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_attempts": {
+      "name": "oauth_attempts",
+      "columns": {
+        "state_hash": {
+          "name": "state_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "browser_hash": {
+          "name": "browser_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_verifier": {
+          "name": "encrypted_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "consumed_at": {
+          "name": "consumed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "oauth_attempts_app_id_oauth_apps_id_fk": {
+          "name": "oauth_attempts_app_id_oauth_apps_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oauth_attempts_connection_id_connections_id_fk": {
+          "name": "oauth_attempts_connection_id_connections_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

drizzle/meta/0003_snapshot.json

@@ -0,0 +1,562 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "d021bc5b-2422-467a-ab92-2493da6e642a",
+  "prevId": "ebfb67e2-a014-4d40-89e3-30c9b55cf047",
+  "tables": {
+    "connection_credentials": {
+      "name": "connection_credentials",
+      "columns": {
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_token": {
+          "name": "encrypted_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "connection_credentials_connection_id_connections_id_fk": {
+          "name": "connection_credentials_connection_id_connections_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "connection_credentials_app_id_oauth_apps_id_fk": {
+          "name": "connection_credentials_app_id_oauth_apps_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "connections": {
+      "name": "connections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "relay_profile": {
+          "name": "relay_profile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "connections_account": {
+          "name": "connections_account",
+          "columns": ["platform", "origin", "account_id"],
+          "isUnique": true
+        },
+        "connections_relay_profile": {
+          "name": "connections_relay_profile",
+          "columns": ["origin", "relay_profile"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "deck_columns": {
+      "name": "deck_columns",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_id": {
+          "name": "deck_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "deck_columns_position": {
+          "name": "deck_columns_position",
+          "columns": ["deck_id", "position"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "deck_columns_deck_id_decks_id_fk": {
+          "name": "deck_columns_deck_id_decks_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "decks",
+          "columnsFrom": ["deck_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deck_columns_connection_id_connections_id_fk": {
+          "name": "deck_columns_connection_id_connections_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "deck_columns_deck_id_id_pk": {
+          "columns": ["deck_id", "id"],
+          "name": "deck_columns_deck_id_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "deck_columns_valid_position": {
+          "name": "deck_columns_valid_position",
+          "value": "\"deck_columns\".\"position\" >= 0"
+        }
+      }
+    },
+    "decks": {
+      "name": "decks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "decks_positive_revision": {
+          "name": "decks_positive_revision",
+          "value": "\"decks\".\"revision\" >= 1"
+        }
+      }
+    },
+    "legacy_imports": {
+      "name": "legacy_imports",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_hash": {
+          "name": "payload_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_ids": {
+          "name": "deck_ids",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_apps": {
+      "name": "oauth_apps",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_client_secret": {
+          "name": "encrypted_client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "oauth_apps_configuration": {
+          "name": "oauth_apps_configuration",
+          "columns": ["origin", "redirect_uri", "scopes"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_attempts": {
+      "name": "oauth_attempts",
+      "columns": {
+        "state_hash": {
+          "name": "state_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "browser_hash": {
+          "name": "browser_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_verifier": {
+          "name": "encrypted_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "consumed_at": {
+          "name": "consumed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "oauth_attempts_app_id_oauth_apps_id_fk": {
+          "name": "oauth_attempts_app_id_oauth_apps_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oauth_attempts_connection_id_connections_id_fk": {
+          "name": "oauth_attempts_connection_id_connections_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "research_sessions": {
+      "name": "research_sessions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "snapshot": {
+          "name": "snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "research_state": {
+      "name": "research_state",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "active_session_id": {
+          "name": "active_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "research_state_active_session_id_research_sessions_id_fk": {
+          "name": "research_state_active_session_id_research_sessions_id_fk",
+          "tableFrom": "research_state",
+          "tableTo": "research_sessions",
+          "columnsFrom": ["active_session_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "research_state_singleton": {
+          "name": "research_state_singleton",
+          "value": "\"research_state\".\"id\" = 1"
+        }
+      }
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

drizzle/meta/0004_snapshot.json

@@ -0,0 +1,696 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "52f68a9d-b9da-4739-9635-b0b5e3e8040b",
+  "prevId": "d021bc5b-2422-467a-ab92-2493da6e642a",
+  "tables": {
+    "auth_sessions": {
+      "name": "auth_sessions",
+      "columns": {
+        "token_hash": {
+          "name": "token_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "auth_sessions_owner_id_workspace_owner_id_fk": {
+          "name": "auth_sessions_owner_id_workspace_owner_id_fk",
+          "tableFrom": "auth_sessions",
+          "tableTo": "workspace_owner",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "auth_throttle": {
+      "name": "auth_throttle",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "attempts": {
+          "name": "attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reset_at": {
+          "name": "reset_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "auth_throttle_singleton": {
+          "name": "auth_throttle_singleton",
+          "value": "\"auth_throttle\".\"id\" = 1"
+        }
+      }
+    },
+    "connection_credentials": {
+      "name": "connection_credentials",
+      "columns": {
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_token": {
+          "name": "encrypted_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "connection_credentials_connection_id_connections_id_fk": {
+          "name": "connection_credentials_connection_id_connections_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "connection_credentials_app_id_oauth_apps_id_fk": {
+          "name": "connection_credentials_app_id_oauth_apps_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "connections": {
+      "name": "connections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "relay_profile": {
+          "name": "relay_profile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "connections_account": {
+          "name": "connections_account",
+          "columns": ["platform", "origin", "account_id"],
+          "isUnique": true
+        },
+        "connections_relay_profile": {
+          "name": "connections_relay_profile",
+          "columns": ["origin", "relay_profile"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "deck_columns": {
+      "name": "deck_columns",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_id": {
+          "name": "deck_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "deck_columns_position": {
+          "name": "deck_columns_position",
+          "columns": ["deck_id", "position"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "deck_columns_deck_id_decks_id_fk": {
+          "name": "deck_columns_deck_id_decks_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "decks",
+          "columnsFrom": ["deck_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deck_columns_connection_id_connections_id_fk": {
+          "name": "deck_columns_connection_id_connections_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "deck_columns_deck_id_id_pk": {
+          "columns": ["deck_id", "id"],
+          "name": "deck_columns_deck_id_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "deck_columns_valid_position": {
+          "name": "deck_columns_valid_position",
+          "value": "\"deck_columns\".\"position\" >= 0"
+        }
+      }
+    },
+    "decks": {
+      "name": "decks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "decks_positive_revision": {
+          "name": "decks_positive_revision",
+          "value": "\"decks\".\"revision\" >= 1"
+        }
+      }
+    },
+    "legacy_imports": {
+      "name": "legacy_imports",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_hash": {
+          "name": "payload_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_ids": {
+          "name": "deck_ids",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_apps": {
+      "name": "oauth_apps",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_client_secret": {
+          "name": "encrypted_client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "oauth_apps_configuration": {
+          "name": "oauth_apps_configuration",
+          "columns": ["origin", "redirect_uri", "scopes"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_attempts": {
+      "name": "oauth_attempts",
+      "columns": {
+        "state_hash": {
+          "name": "state_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "browser_hash": {
+          "name": "browser_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_verifier": {
+          "name": "encrypted_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "consumed_at": {
+          "name": "consumed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "oauth_attempts_app_id_oauth_apps_id_fk": {
+          "name": "oauth_attempts_app_id_oauth_apps_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oauth_attempts_connection_id_connections_id_fk": {
+          "name": "oauth_attempts_connection_id_connections_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "research_sessions": {
+      "name": "research_sessions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "snapshot": {
+          "name": "snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "research_state": {
+      "name": "research_state",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "active_session_id": {
+          "name": "active_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "research_state_active_session_id_research_sessions_id_fk": {
+          "name": "research_state_active_session_id_research_sessions_id_fk",
+          "tableFrom": "research_state",
+          "tableTo": "research_sessions",
+          "columnsFrom": ["active_session_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "research_state_singleton": {
+          "name": "research_state_singleton",
+          "value": "\"research_state\".\"id\" = 1"
+        }
+      }
+    },
+    "workspace_owner": {
+      "name": "workspace_owner",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "onboarding_completed_at": {
+          "name": "onboarding_completed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "workspace_owner_singleton": {
+          "name": "workspace_owner_singleton",
+          "value": "\"workspace_owner\".\"id\" = 1"
+        }
+      }
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

drizzle/meta/0005_snapshot.json

@@ -0,0 +1,657 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "7a44ef34-89ad-4ab4-829d-f6669bd72471",
+  "prevId": "52f68a9d-b9da-4739-9635-b0b5e3e8040b",
+  "tables": {
+    "auth_sessions": {
+      "name": "auth_sessions",
+      "columns": {
+        "token_hash": {
+          "name": "token_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "auth_sessions_owner_id_workspace_owner_id_fk": {
+          "name": "auth_sessions_owner_id_workspace_owner_id_fk",
+          "tableFrom": "auth_sessions",
+          "tableTo": "workspace_owner",
+          "columnsFrom": ["owner_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "auth_throttle": {
+      "name": "auth_throttle",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "attempts": {
+          "name": "attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reset_at": {
+          "name": "reset_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "auth_throttle_singleton": {
+          "name": "auth_throttle_singleton",
+          "value": "\"auth_throttle\".\"id\" = 1"
+        }
+      }
+    },
+    "connection_credentials": {
+      "name": "connection_credentials",
+      "columns": {
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_token": {
+          "name": "encrypted_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "connection_credentials_connection_id_connections_id_fk": {
+          "name": "connection_credentials_connection_id_connections_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "connection_credentials_app_id_oauth_apps_id_fk": {
+          "name": "connection_credentials_app_id_oauth_apps_id_fk",
+          "tableFrom": "connection_credentials",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "connections": {
+      "name": "connections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "relay_profile": {
+          "name": "relay_profile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "connections_account": {
+          "name": "connections_account",
+          "columns": ["platform", "origin", "account_id"],
+          "isUnique": true
+        },
+        "connections_relay_profile": {
+          "name": "connections_relay_profile",
+          "columns": ["origin", "relay_profile"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "deck_columns": {
+      "name": "deck_columns",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_id": {
+          "name": "deck_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "deck_columns_position": {
+          "name": "deck_columns_position",
+          "columns": ["deck_id", "position"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "deck_columns_deck_id_decks_id_fk": {
+          "name": "deck_columns_deck_id_decks_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "decks",
+          "columnsFrom": ["deck_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "deck_columns_connection_id_connections_id_fk": {
+          "name": "deck_columns_connection_id_connections_id_fk",
+          "tableFrom": "deck_columns",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "deck_columns_deck_id_id_pk": {
+          "columns": ["deck_id", "id"],
+          "name": "deck_columns_deck_id_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "deck_columns_valid_position": {
+          "name": "deck_columns_valid_position",
+          "value": "\"deck_columns\".\"position\" >= 0"
+        }
+      }
+    },
+    "decks": {
+      "name": "decks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "decks_positive_revision": {
+          "name": "decks_positive_revision",
+          "value": "\"decks\".\"revision\" >= 1"
+        }
+      }
+    },
+    "legacy_imports": {
+      "name": "legacy_imports",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_hash": {
+          "name": "payload_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "deck_ids": {
+          "name": "deck_ids",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_apps": {
+      "name": "oauth_apps",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "redirect_uri": {
+          "name": "redirect_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_client_secret": {
+          "name": "encrypted_client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "oauth_apps_configuration": {
+          "name": "oauth_apps_configuration",
+          "columns": ["origin", "redirect_uri", "scopes"],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "oauth_attempts": {
+      "name": "oauth_attempts",
+      "columns": {
+        "state_hash": {
+          "name": "state_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "browser_hash": {
+          "name": "browser_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "app_id": {
+          "name": "app_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "encrypted_verifier": {
+          "name": "encrypted_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connection_id": {
+          "name": "connection_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "consumed_at": {
+          "name": "consumed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "oauth_attempts_app_id_oauth_apps_id_fk": {
+          "name": "oauth_attempts_app_id_oauth_apps_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "oauth_apps",
+          "columnsFrom": ["app_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oauth_attempts_connection_id_connections_id_fk": {
+          "name": "oauth_attempts_connection_id_connections_id_fk",
+          "tableFrom": "oauth_attempts",
+          "tableTo": "connections",
+          "columnsFrom": ["connection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "research_sessions": {
+      "name": "research_sessions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "snapshot": {
+          "name": "snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "workspace_owner": {
+      "name": "workspace_owner",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "onboarding_completed_at": {
+          "name": "onboarding_completed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "workspace_owner_singleton": {
+          "name": "workspace_owner_singleton",
+          "value": "\"workspace_owner\".\"id\" = 1"
+        }
+      }
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

drizzle/meta/_journal.json

@@ -0,0 +1,48 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1790234301369,
+      "tag": "0000_aspiring_bloodstorm",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1790234518415,
+      "tag": "0001_many_fat_cobra",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1790234736939,
+      "tag": "0002_fine_master_chief",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1790242505709,
+      "tag": "0003_romantic_scrambler",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1790589494499,
+      "tag": "0004_good_natasha_romanoff",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "6",
+      "when": 1790591720807,
+      "tag": "0005_salty_madripoor",
+      "breakpoints": true
+    }
+  ]
+}

e2e/a11y/homePage.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from '../fixtures'
-
-test('home page has no accessibility violations', async ({
-  a11y,
-  homePage,
-}) => {
-  await homePage.goTo()
-  await expect(homePage.articlesLocator).toHaveCount(0)
-
-  const result = await a11y().analyze()
-  expect(result.violations).toEqual([])
-})

e2e/a11y/listsPage.test.ts

@@ -1,24 +0,0 @@
-import { expect, test } from '../fixtures'
-
-test('list picker has no accessibility violations', async ({
-  a11y,
-  listsPage,
-}) => {
-  await listsPage.goTo()
-  await expect(listsPage.articlesLocator).toHaveCount(0)
-
-  const result = await a11y().analyze()
-  expect(result.violations).toEqual([])
-})
-
-test('list timeline has no accessibility violations', async ({
-  a11y,
-  listsPage,
-}) => {
-  await listsPage.goTo()
-  await listsPage.openList(/My E2E List.*10 メンバー/)
-  await expect(listsPage.endOfFeedLocator).toBeVisible()
-
-  const result = await a11y().analyze()
-  expect(result.violations).toEqual([])
-})

e2e/a11y/searchPage.test.ts

@@ -1,24 +0,0 @@
-import { expect, test } from '../fixtures'
-
-test('empty search page has no accessibility violations', async ({
-  a11y,
-  searchPage,
-}) => {
-  await searchPage.goTo()
-  await expect(searchPage.articlesLocator).toHaveCount(0)
-
-  const result = await a11y().analyze()
-  expect(result.violations).toEqual([])
-})
-
-test('search results have no accessibility violations', async ({
-  a11y,
-  searchPage,
-}) => {
-  await searchPage.goTo()
-  await searchPage.search('AI lang:ja')
-  await expect(searchPage.endOfFeedLocator).toBeVisible()
-
-  const result = await a11y().analyze()
-  expect(result.violations).toEqual([])
-})

e2e/a11y/threadPage.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from '../fixtures'
-
-test('conversation has no accessibility violations', async ({
-  a11y,
-  threadPage,
-}) => {
-  await threadPage.goTo('yuta', '1001')
-  await expect(threadPage.endOfFeedLocator).toBeVisible()
-
-  const result = await a11y().analyze()
-  expect(result.violations).toEqual([])
-})

e2e/a11y/userPage.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from '../fixtures'
-
-test('user timeline has no accessibility violations', async ({
-  a11y,
-  userPage,
-}) => {
-  await userPage.goTo('yuta')
-  await expect(userPage.endOfFeedLocator).toBeVisible()
-
-  const result = await a11y().analyze()
-  expect(result.violations).toEqual([])
-})

e2e/fixtures.ts

@@ -1,34 +1,88 @@
-import AxeBuilder from '@axe-core/playwright'
-import { test as base } from '@playwright/test'
-import { HomePage } from './models/HomePage'
-import { ListsPage } from './models/ListsPage'
-import { SearchPage } from './models/SearchPage'
-import { ThreadPage } from './models/ThreadPage'
-import { UserPage } from './models/UserPage'
+import { basename, dirname, isAbsolute } from "node:path";
+import AxeBuilder from "@axe-core/playwright";
+import { test as base } from "@playwright/test";
+import {
+  completeOnboarding,
+  createOwner,
+  readAuthState,
+  signIn,
+} from "../src/features/auth/auth.server";
+import { openDatabase } from "../src/features/storage/database.server";
 
-type Fixtures = {
-  a11y: () => AxeBuilder
-  homePage: HomePage
-  listsPage: ListsPage
-  searchPage: SearchPage
-  threadPage: ThreadPage
-  userPage: UserPage
-}
-
-export const test = base.extend<Fixtures>({
-  a11y: async ({ page }, use) => {
-    const makeAxeBuilder = () =>
-      new AxeBuilder({ page })
-        .withTags(['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa'])
-        .disableRules(['meta-viewport'])
-
-    await use(makeAxeBuilder)
+export const test = base.extend<{
+  a11y: () => AxeBuilder;
+  resetDecks: undefined;
+  sessionToken: string;
+}>({
+  // oxlint-disable-next-line no-empty-pattern -- Playwright requires destructured fixture arguments.
+  sessionToken: async ({}, use) => {
+    const path = process.env.TWITTER_LITE_E2E_DB_PATH;
+    if (!path || !basename(dirname(path)).startsWith("twitter-lite-e2e-"))
+      throw new Error("Isolated E2E database is required.");
+    const database = openDatabase(path);
+    const credentials = {
+      email: "[email protected]",
+      password: "E2E-only-passphrase-2026",
+    };
+    process.env.WORKSPACE_SETUP_TOKEN = "isolated-e2e-setup-token-not-for-production";
+    const result = readAuthState(database).needsSetup
+      ? await createOwner(
+          {
+            ...credentials,
+            name: "Yuta",
+            setupToken: process.env.WORKSPACE_SETUP_TOKEN,
+          },
+          database,
+        )
+      : await signIn(credentials, database);
+    if (!result.owner.onboardingCompletedAt)
+      completeOnboarding(result.sessionToken, { name: "Yuta" }, database);
+    database.$client.close();
+    await use(result.sessionToken);
   },
-  homePage: ({ page }, use) => use(new HomePage(page)),
-  listsPage: ({ page }, use) => use(new ListsPage(page)),
-  searchPage: ({ page }, use) => use(new SearchPage(page)),
-  threadPage: ({ page }, use) => use(new ThreadPage(page)),
-  userPage: ({ page }, use) => use(new UserPage(page)),
-})
+  storageState: async ({ sessionToken }, use) => {
+    await use({
+      cookies: [
+        {
+          name: "workspace_session",
+          value: sessionToken,
+          domain: "127.0.0.1",
+          path: "/",
+          expires: Math.floor(Date.now() / 1000) + 3600,
+          httpOnly: true,
+          secure: false,
+          sameSite: "Lax",
+        },
+      ],
+      origins: [],
+    });
+  },
+  resetDecks: [
+    // oxlint-disable-next-line no-empty-pattern -- Playwright requires destructured fixture arguments.
+    async ({}, use) => {
+      const path = process.env.TWITTER_LITE_E2E_DB_PATH;
+      if (
+        !path ||
+        !isAbsolute(path) ||
+        !basename(dirname(path)).startsWith("twitter-lite-e2e-") ||
+        basename(path) !== "workspace.sqlite"
+      )
+        throw new Error("Isolated E2E database is required.");
+      const database = openDatabase(path).$client;
+      database.pragma("foreign_keys = ON");
+      database.exec("DELETE FROM decks; DELETE FROM legacy_imports;");
+      database.close();
+      await use(undefined);
+    },
+    { auto: true },
+  ],
+  a11y: async ({ page }, use) => {
+    await use(() =>
+      new AxeBuilder({ page })
+        .withTags(["wcag2a", "wcag2aa", "wcag21a", "wcag21aa"])
+        .disableRules(["meta-viewport"]),
+    );
+  },
+});
 
-export { expect } from '@playwright/test'
+export { expect } from "@playwright/test";

e2e/fixtures/twitter.ts

@@ -0,0 +1,31 @@
+import type { TweetLegacy } from "../generated/twitter-openapi/client.ts";
+
+interface TweetLegacyFixtureOptions {
+  conversationId?: string;
+  inReplyTo?: string;
+  replyCount?: number;
+}
+
+export const tweetLegacyFixture = (
+  id: string,
+  text: string,
+  { conversationId = id, inReplyTo, replyCount = 1 }: TweetLegacyFixtureOptions = {},
+): TweetLegacy => ({
+  bookmark_count: 0,
+  bookmarked: false,
+  conversation_id_str: conversationId,
+  created_at: "Mon Jul 13 00:00:00 +0000 2026",
+  display_text_range: [0, text.length],
+  favorite_count: 3,
+  favorited: false,
+  full_text: text,
+  id_str: id,
+  ...(inReplyTo ? { in_reply_to_status_id_str: inReplyTo } : {}),
+  is_quote_status: false,
+  lang: "ja",
+  quote_count: 0,
+  reply_count: replyCount,
+  retweet_count: 2,
+  retweeted: false,
+  user_id_str: "42",
+});

e2e/integrations/access.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from "../fixtures";
+
+test("owner can open the app but missing or foreign identity is forbidden", async ({ request }) => {
+  expect((await request.get("/")).status()).toBe(200);
+  expect((await request.get("/", { headers: { "Tailscale-User-Login": "" } })).status()).toBe(403);
+  expect(
+    (
+      await request.get("/", {
+        headers: { "Tailscale-User-Login": "[email protected]" },
+      })
+    ).status(),
+  ).toBe(403);
+});
+
+test("mutations require exact Origin even with same-origin Fetch Metadata", async ({ request }) => {
+  expect((await request.post("/")).status()).toBe(403);
+  expect(
+    (
+      await request.post("/", {
+        headers: {
+          Origin: "https://other.invalid",
+          "Sec-Fetch-Site": "same-origin",
+        },
+      })
+    ).status(),
+  ).toBe(403);
+});
+
+test("server functions also reject foreign identity and cross-site calls", async ({
+  page,
+  request,
+}) => {
+  const serverRequest = page.waitForRequest((request) => request.url().includes("/_serverFn/"));
+  await page.goto("/deck");
+  const url = (await serverRequest).url();
+  expect(
+    (
+      await request.get(url, {
+        headers: {
+          "Tailscale-User-Login": "[email protected]",
+          "Sec-Fetch-Site": "same-origin",
+        },
+      })
+    ).status(),
+  ).toBe(403);
+  expect(
+    (
+      await request.get(url, {
+        headers: { "Sec-Fetch-Site": "cross-site" },
+      })
+    ).status(),
+  ).toBe(403);
+});

e2e/integrations/auth.test.ts

@@ -0,0 +1,134 @@
+import { openDatabase } from "../../src/features/storage/database.server";
+import { expect, test } from "../fixtures";
+
+const origin = "http://127.0.0.1:4173";
+
+test("creates the owner once and enters onboarding with a real session", async ({
+  page,
+  context,
+  a11y,
+}) => {
+  const db = openDatabase(process.env.TWITTER_LITE_E2E_DB_PATH ?? "");
+  db.$client.exec("DELETE FROM workspace_owner; DELETE FROM auth_throttle;");
+  db.$client.close();
+  await context.clearCookies();
+  await page.goto("/", { waitUntil: "networkidle" });
+  await expect(page).toHaveURL(/\/setup$/);
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await page.getByLabel("Your name", { exact: true }).fill("Yuta");
+  await page.getByLabel("Email address").fill("[email protected]");
+  await page.getByLabel("Password", { exact: true }).fill("E2E-only-passphrase-2026");
+  await page.getByLabel("Confirm password", { exact: true }).fill("E2E-only-passphrase-2026");
+  await page.getByLabel("Setup code").fill("isolated-e2e-setup-token-not-for-production");
+  await page.getByRole("button", { name: "Create account", exact: true }).click();
+  await expect(page).toHaveURL(/\/onboarding$/);
+  await page.waitForLoadState("networkidle");
+  await page.getByRole("button", { name: "Continue", exact: true }).click();
+  await page.getByRole("button", { name: "Open workspace" }).click();
+  await expect(page.getByRole("heading", { name: "Good morning, Yuta" })).toBeVisible();
+});
+
+test("requires login for documents, server functions, and live updates", async ({
+  page,
+  context,
+}) => {
+  const serverRequest = page.waitForRequest((request) => request.url().includes("/_serverFn/"));
+  await page.goto("/deck");
+  const serverUrl = (await serverRequest).url();
+  await context.clearCookies();
+  for (const path of ["/api/research/events", serverUrl]) {
+    const result = await context.request.get(path, {
+      headers: { Origin: origin, "Sec-Fetch-Site": "same-origin" },
+    });
+    expect(result.status()).toBe(401);
+  }
+  await page.goto("/journal");
+  await expect(page).toHaveURL(/\/login(?:\?|$)/);
+  await expect(page.getByRole("heading", { name: "Welcome back." })).toBeVisible();
+  await expect(page.getByRole("link", { name: "Journal", exact: true })).toHaveCount(0);
+});
+
+test("signs in and revokes the session on sign out", async ({ page, context, a11y }) => {
+  await context.clearCookies();
+  await page.goto("/login", { waitUntil: "networkidle" });
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await page.getByLabel("Email address").fill("[email protected]");
+  await page.getByLabel("Password", { exact: true }).fill("Wrong-passphrase-2026");
+  await page.getByRole("button", { name: "Sign in", exact: true }).click();
+  await expect(page.getByRole("alert")).toContainText("Invalid email or password.");
+  await page.getByLabel("Password", { exact: true }).fill("E2E-only-passphrase-2026");
+  await page.getByRole("button", { name: "Sign in", exact: true }).click();
+  await expect(page).toHaveURL(`${origin}/`);
+  await page.waitForLoadState("networkidle");
+  const token = (await context.cookies()).find((cookie) => cookie.name === "workspace_session");
+  expect(token?.httpOnly).toBe(true);
+  expect(token?.sameSite).toBe("Lax");
+  await page.getByRole("button", { name: "Manage connected accounts" }).click();
+  await page.getByRole("button", { name: "Sign out", exact: true }).click();
+  await expect(page).toHaveURL(/\/login(?:\?|$)/);
+  const replay = await context.request.get("/api/auth", {
+    headers: { Cookie: `workspace_session=${token?.value}` },
+  });
+  expect((await replay.json()).owner).toBeNull();
+  await page.goBack();
+  await expect(page.getByRole("link", { name: "Home", exact: true })).toHaveCount(0);
+});
+
+test("requires onboarding and remembers its completion and name", async ({
+  page,
+  request,
+  a11y,
+}) => {
+  const db = openDatabase(process.env.TWITTER_LITE_E2E_DB_PATH ?? "");
+  db.$client
+    .prepare("UPDATE workspace_owner SET onboarding_completed_at = NULL WHERE id = 1")
+    .run();
+  try {
+    expect((await request.get("/api/research/events")).status()).toBe(403);
+    await page.goto("/", { waitUntil: "networkidle" });
+    await expect(page).toHaveURL(/\/onboarding$/);
+    expect((await a11y().analyze()).violations).toEqual([]);
+    await page.getByLabel("What should we call you?").fill("Yuta Test");
+    await page.getByRole("button", { name: "Continue", exact: true }).click();
+    await page.getByRole("button", { name: "Open workspace" }).click();
+    await expect(page.getByRole("heading", { name: "Good morning, Yuta Test" })).toBeVisible();
+    await page.reload();
+    await expect(page.getByRole("heading", { name: "Good morning, Yuta Test" })).toBeVisible();
+    await page.goto("/onboarding");
+    await expect(page).toHaveURL(`${origin}/`);
+  } finally {
+    db.$client
+      .prepare("UPDATE workspace_owner SET name = ?, onboarding_completed_at = ? WHERE id = 1")
+      .run("Yuta", Date.now());
+    db.$client.close();
+  }
+});
+
+test("rejects cross-origin login and further account registration", async ({
+  request,
+  page,
+  context,
+}) => {
+  expect(
+    (
+      await request.post("/api/auth", {
+        headers: { Origin: "https://other.invalid" },
+        data: { action: "logout" },
+      })
+    ).status(),
+  ).toBe(403);
+  const result = await request.post("/api/auth", {
+    headers: { Origin: origin },
+    data: {
+      action: "setup",
+      email: "[email protected]",
+      name: "Intruder",
+      password: "Long-enough-password",
+      setupToken: "arbitrary-token",
+    },
+  });
+  expect(result.status()).toBe(409);
+  await context.clearCookies();
+  await page.goto("/setup");
+  await expect(page).toHaveURL(/\/login(?:\?|$)/);
+});

e2e/integrations/connections.test.ts

@@ -0,0 +1,52 @@
+import { expect, test } from "../fixtures";
+
+test("opens account management after hydration without inheriting real OAuth configuration", async ({
+  page,
+}) => {
+  await page.goto("/deck");
+  await expect(page.getByRole("button", { name: "Rename", includeHidden: true })).toBeEnabled();
+  const manage = page.getByRole("button", { name: "Manage connected accounts" });
+  if (!(await manage.isVisible())) {
+    await page.getByRole("button", { name: "Toggle sidebar" }).click();
+  }
+  await expect(manage).toBeEnabled();
+  await manage.click();
+  const dialog = page.getByRole("dialog", { name: "Connected accounts" });
+  await expect(dialog).toBeVisible();
+  await expect(dialog.getByText("No Mastodon servers have been configured yet.")).toBeVisible();
+  await expect(dialog.getByRole("button", { name: "Authorize with Mastodon" })).toHaveCount(0);
+  await page.keyboard.press("Escape");
+  await expect(dialog).toHaveCount(0);
+  await expect(manage).toBeFocused();
+});
+
+test("opens account management from the inbox footer and restores focus on close", async ({
+  page,
+  a11y,
+}) => {
+  await page.goto("/inbox");
+  await page.waitForLoadState("networkidle");
+  const manage = page.getByRole("button", { name: "Manage connected accounts" });
+  await expect(manage).toBeVisible();
+  await manage.click();
+  const dialog = page.getByRole("dialog", { name: "Connected accounts" });
+  await expect(dialog).toBeVisible();
+  await expect(dialog.getByText("No Mastodon servers have been configured yet.")).toBeVisible();
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await page.keyboard.press("Escape");
+  await expect(dialog).toHaveCount(0);
+  await expect(manage).toBeFocused();
+  await expect(page.getByRole("textbox", { name: "Search articles" })).toBeVisible();
+});
+
+test("rejects an unbound OAuth callback without contacting an instance", async ({ page }) => {
+  await page.goto("/oauth/mastodon/callback?state=invalid&code=not-a-real-code");
+  await expect(page).toHaveURL(/\/deck\?mastodon=failed$/);
+  await expect(page.getByRole("alert")).toContainText("Could not complete Mastodon authorization.");
+  await expect(page.getByRole("button", { name: "Rename", includeHidden: true })).toBeEnabled();
+  const manage = page.getByRole("button", { name: "Manage connected accounts" });
+  if (!(await manage.isVisible())) {
+    await page.getByRole("button", { name: "Toggle sidebar" }).click();
+  }
+  await expect(page.getByRole("button", { name: "Manage connected accounts" })).toBeEnabled();
+});

e2e/integrations/deck.test.ts

@@ -0,0 +1,327 @@
+import type { Page } from "@playwright/test";
+import { expect, test } from "../fixtures";
+import { closeMobileSidebar, showDeckManagement } from "../workspace";
+
+async function addColumn(
+  page: Page,
+  title: string,
+  query: string,
+  profile = "e2e",
+  kind = "search",
+) {
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Add column", exact: true }).click();
+  const editor = page.getByRole("form", { name: "Add column", exact: true });
+  await editor.getByLabel("Column name", { exact: true }).fill(title);
+  await editor
+    .getByRole("combobox", { name: "Connection profile", exact: true })
+    .selectOption({ label: profile });
+  await editor.getByRole("combobox", { name: "Column type", exact: true }).selectOption(kind);
+  await editor
+    .getByLabel(kind === "search" ? "Twitter search query" : kind === "user" ? "User" : "List", {
+      exact: true,
+    })
+    .fill(query);
+  await editor.getByRole("button", { name: "Add and search" }).click();
+  await closeMobileSidebar(page);
+  await expect(
+    page.getByRole("region", { name: title, exact: true }).locator("article").first(),
+  ).toBeVisible();
+}
+
+test.beforeEach(async ({ page }) => {
+  await page.goto("/deck");
+  await expect(page.getByRole("button", { name: "Save as deck", exact: true })).toBeEnabled();
+  await page.getByRole("button", { name: "Save as deck", exact: true }).click();
+  await showDeckManagement(page);
+  await expect(page.getByText("Saved to server · Shared across devices")).toBeVisible();
+  await closeMobileSidebar(page);
+});
+
+test("binds identical searches to independent profiles through paging, editing and reload", async ({
+  page,
+}) => {
+  await addColumn(page, "通常の接続", "same-query");
+  await addColumn(page, "別の接続", "same-query", "alternate");
+  const first = page.getByRole("region", { name: "通常の接続", exact: true });
+  const second = page.getByRole("region", { name: "別の接続", exact: true });
+  await expect(first.getByText("Latest · all page 1", { exact: true })).toBeVisible();
+  await expect(second.getByText("alternate · Latest · all page 1", { exact: true })).toBeVisible();
+  await first.getByRole("button", { name: "Load more" }).click();
+  await expect(first.locator("article")).toHaveCount(2);
+  await expect(second.locator("article")).toHaveCount(1);
+  await second.getByRole("button", { name: "Load more" }).click();
+  await expect(second.getByText("alternate · Latest · all page 2")).toBeVisible();
+  await second.getByRole("button", { name: "Actions for 別の接続" }).click();
+  await page.getByRole("menuitem", { name: "Edit", exact: true }).click();
+  await page
+    .getByRole("combobox", { name: "Connection profile", exact: true })
+    .selectOption({ label: "e2e" });
+  await page.getByRole("button", { name: "Save changes" }).click();
+  await expect(second.getByText("Latest · all page 1", { exact: true })).toBeVisible();
+  await expect(second.getByText("alternate · Latest · all page 1")).toHaveCount(0);
+  await page.reload();
+  await expect(second.getByText("Latest · all page 1", { exact: true })).toBeVisible();
+  await expect(first.locator("article")).toHaveCount(1);
+});
+
+test("creates, switches, renames and deletes persisted deck profiles", async ({ page }) => {
+  await page.getByRole("button", { name: "Rename" }).click();
+  await page.getByLabel("Research topic / deck name").fill("最初の調査");
+  await page.getByRole("button", { name: "Save name" }).click();
+  await addColumn(page, "最初の観点", "first-deck");
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Create deck", exact: true }).click();
+  await page.getByLabel("New deck name").fill("別の調査");
+  await page.getByRole("button", { name: "Create", exact: true }).click();
+  await expect(page.locator(".deck-column")).toHaveCount(0);
+  await addColumn(page, "別の観点", "second-deck", "alternate");
+  await showDeckManagement(page);
+  await page.getByLabel("Deck profile", { exact: true }).selectOption({ label: "最初の調査" });
+  await closeMobileSidebar(page);
+  await expect(page.locator(".deck-column h2")).toHaveText(["最初の観点"]);
+  await page.reload();
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("最初の調査");
+  await showDeckManagement(page);
+  await page.getByLabel("Deck profile", { exact: true }).selectOption({ label: "別の調査" });
+  await closeMobileSidebar(page);
+  await expect(page.locator(".deck-column h2")).toHaveText(["別の観点"]);
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Delete deck", exact: true }).click();
+  await page.getByRole("button", { name: "Delete", exact: true }).click();
+  await page.reload();
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("最初の調査");
+  await showDeckManagement(page);
+  await expect(page.getByLabel("Deck profile", { exact: true }).locator("option")).toHaveCount(1);
+});
+
+test("reads user and list timelines within columns and reorders, deletes and restores them", async ({
+  page,
+}) => {
+  await addColumn(page, "アカウント", "yuta", "alternate", "user");
+  await addColumn(page, "リストの投稿", "1234567890", "e2e", "list");
+  const user = page.getByRole("region", { name: "アカウント", exact: true });
+  const list = page.getByRole("region", { name: "リストの投稿", exact: true });
+  await expect(user.getByText("alternate profile page 1")).toBeVisible();
+  await expect(list.getByText("list page 1")).toBeVisible();
+  await list.getByRole("button", { name: "Load more" }).click();
+  await expect(list.getByText("list page 2")).toBeVisible();
+  await list.getByRole("button", { name: "Actions for リストの投稿" }).click();
+  await page.getByRole("menuitem", { name: "Move リストの投稿 left" }).click();
+  await expect(page.locator(".deck-column h2")).toHaveText(["リストの投稿", "アカウント"]);
+  await list.getByRole("button", { name: "Actions for リストの投稿" }).click();
+  await page.getByRole("menuitem", { name: "Delete リストの投稿" }).click();
+  await page.getByRole("button", { name: "Undo" }).click();
+  await expect(page.locator(".deck-column h2")).toHaveText(["リストの投稿", "アカウント"]);
+  await page.reload();
+  await expect(user.getByText("alternate profile page 1")).toBeVisible();
+  await expect(list.getByText("list page 1")).toBeVisible();
+});
+
+test("keeps other columns usable when pagination fails and retries that column", async ({
+  page,
+}, testInfo) => {
+  await addColumn(page, "失敗する検索", `retry-deck-${testInfo.project.name}`);
+  await addColumn(page, "別の検索", "independent-deck");
+  const failed = page.getByRole("region", { name: "失敗する検索", exact: true });
+  const other = page.getByRole("region", { name: "別の検索", exact: true });
+  await failed.getByRole("button", { name: "Load more" }).click();
+  await expect(failed.getByRole("alert")).toBeVisible();
+  await expect(failed.locator("article")).toHaveCount(1);
+  await other.getByRole("button", { name: "Load more" }).click();
+  await expect(other.locator("article")).toHaveCount(2);
+  await failed.getByRole("button", { name: "Retry" }).click();
+  await expect(failed.locator("article")).toHaveCount(2);
+});
+
+test("keeps the deck and editor accessible within narrow viewports", async ({
+  page,
+  a11y,
+}, testInfo) => {
+  await addColumn(page, "日本語の反応", "WebMCP lang:ja");
+  await addColumn(page, "海外の反応", "WebMCP lang:en", "alternate");
+  await addColumn(page, "公式アカウント", "OpenAI", "e2e", "user");
+  for (const width of [320, 375, 414, 768]) {
+    await page.setViewportSize({ width, height: 900 });
+    expect(await page.evaluate(() => document.documentElement.scrollWidth > innerWidth)).toBe(
+      false,
+    );
+    expect(await page.evaluate(() => document.documentElement.scrollHeight <= innerHeight)).toBe(
+      true,
+    );
+    const board = await page.locator(".deck-board").boundingBox();
+    expect(board).not.toBeNull();
+    expect((board?.y ?? 0) + (board?.height ?? 0)).toBeLessThanOrEqual(901);
+  }
+  await page.setViewportSize({
+    width: testInfo.project.name === "desktop" ? 1440 : 393,
+    height: 900,
+  });
+  await expect(page.getByRole("navigation", { name: "Columns" })).toHaveCount(0);
+  await expect(page.getByRole("heading", { name: "公式アカウント", exact: true })).toBeVisible();
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await page.screenshot({
+    path: testInfo.outputPath("deck-populated.png"),
+    fullPage: true,
+  });
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Add column", exact: true }).click();
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await page.screenshot({
+    path: testInfo.outputPath("deck.png"),
+    fullPage: true,
+  });
+});
+
+test("closes the column editor with Escape and restores focus without applying edits", async ({
+  page,
+}) => {
+  await showDeckManagement(page);
+  const opener = page.getByRole("button", { name: "Add column", exact: true });
+  await opener.click();
+  await expect(page.getByRole("dialog", { name: "Add column", exact: true })).toBeVisible();
+  await page.getByLabel("Column name", { exact: true }).fill("キャンセルする観点");
+  await page.keyboard.press("Escape");
+  await expect(page.getByRole("dialog", { name: "Add column", exact: true })).toHaveCount(0);
+  await expect(opener).toBeFocused();
+  await expect(page.locator(".deck-column")).toHaveCount(0);
+  await opener.click();
+  await expect(page.getByLabel("Column name", { exact: true })).toHaveValue("");
+});
+
+test("does not overwrite unreadable storage on reload", async ({ page }) => {
+  await page.evaluate(() => localStorage.setItem("twitter-lite-research-deck", "{broken"));
+  await page.reload();
+  await expect(page.getByRole("alert")).toContainText("Unable to load");
+  expect(await page.evaluate(() => localStorage.getItem("twitter-lite-research-deck"))).toBe(
+    "{broken",
+  );
+});
+
+test("selects a list from the column profile catalog and refreshes it on profile change", async ({
+  page,
+}) => {
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Add column", exact: true }).click();
+  await page.getByLabel("Column name", { exact: true }).fill("購読リスト");
+  await page
+    .getByRole("combobox", { name: "Connection profile", exact: true })
+    .selectOption({ label: "e2e" });
+  await page.getByRole("combobox", { name: "Column type", exact: true }).selectOption("list");
+  await expect(page.getByRole("button", { name: "My E2E List", exact: true })).toBeVisible();
+  await page
+    .getByRole("combobox", { name: "Connection profile", exact: true })
+    .selectOption({ label: "alternate" });
+  await expect(page.getByRole("button", { name: "My E2E List", exact: true })).toHaveCount(0);
+  await page.getByRole("button", { name: "Alternate List", exact: true }).click();
+  await expect(page.getByLabel("List", { exact: true })).toHaveValue("1234567890");
+  await page.getByRole("button", { name: "Add and search" }).click();
+  await closeMobileSidebar(page);
+  await expect(
+    page
+      .getByRole("region", { name: "購読リスト", exact: true })
+      .getByText("list page 1", { exact: true }),
+  ).toBeVisible();
+});
+
+test("keeps an open draft through remote edits and rejects its stale save", async ({
+  page,
+  browser,
+  baseURL,
+}) => {
+  const other = await browser.newContext({
+    storageState: await page.context().storageState(),
+    baseURL,
+    extraHTTPHeaders: { "Tailscale-User-Login": "[email protected]" },
+  });
+  try {
+    const device = await other.newPage();
+    await device.goto("/deck");
+    await page.getByRole("button", { name: "Rename" }).click();
+    await page.getByLabel("Research topic / deck name").fill("編集中の名前");
+    await device.getByRole("button", { name: "Rename" }).click();
+    await device.getByLabel("Research topic / deck name").fill("別の端末の変更");
+    await device.getByRole("button", { name: "Save name" }).click();
+    await expect(device.getByRole("heading", { level: 1 })).toHaveText("別の端末の変更");
+    await page.evaluate(() => window.dispatchEvent(new Event("focus")));
+    await expect(page.getByLabel("Research topic / deck name")).toHaveValue("編集中の名前");
+    await page.getByRole("button", { name: "Save name" }).click();
+    await expect(page.getByRole("alert")).toContainText("This deck changed on another device");
+    await expect(page.getByLabel("Research topic / deck name")).toHaveValue("編集中の名前");
+    await page.keyboard.press("Escape");
+    await page.getByRole("button", { name: "Reload latest deck" }).click();
+    await expect(page.getByRole("heading", { level: 1 })).toHaveText("別の端末の変更");
+  } finally {
+    await other.close();
+  }
+});
+
+test("imports old browser decks explicitly and avoids duplicate imports after retry", async ({
+  page,
+}) => {
+  const legacy = {
+    version: 2,
+    activeDeckId: "old",
+    decks: [
+      {
+        id: "old",
+        title: "以前の調査",
+        columns: [
+          {
+            id: "a",
+            title: "以前の観点",
+            profileName: "e2e",
+            source: {
+              platform: "twitter",
+              kind: "search",
+              query: "WebMCP",
+              product: "Latest",
+              following: false,
+            },
+          },
+        ],
+      },
+    ],
+  };
+  await page.evaluate(
+    (legacy) => localStorage.setItem("twitter-lite-research-deck", JSON.stringify(legacy)),
+    legacy,
+  );
+  await page.reload();
+  await showDeckManagement(page);
+  const selector = page.getByLabel("Deck profile", { exact: true });
+  await expect(selector.locator("option")).toHaveCount(1);
+  await closeMobileSidebar(page);
+  await page.getByRole("button", { name: "Import legacy decks" }).click();
+  await showDeckManagement(page);
+  await expect(selector.locator("option")).toHaveCount(2);
+  await selector.selectOption({ label: "以前の調査" });
+  await closeMobileSidebar(page);
+  await expect(page.getByText("Latest · all page 1", { exact: true })).toBeVisible();
+  await page.evaluate(
+    (legacy) => localStorage.setItem("twitter-lite-research-deck", JSON.stringify(legacy)),
+    legacy,
+  );
+  await page.reload();
+  await page.getByRole("button", { name: "Import legacy decks" }).click();
+  await expect(page.getByRole("button", { name: "Import legacy decks" })).toHaveCount(0);
+  await showDeckManagement(page);
+  await expect(selector.locator("option")).toHaveCount(2);
+});
+
+test("preserves a new deck dialog and its draft across the mobile breakpoint", async ({ page }) => {
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Create deck", exact: true }).click();
+  const dialog = page.getByRole("dialog", { name: "Create deck", exact: true });
+  await dialog.getByLabel("New deck name").fill("画面を回転しても残る調査");
+  for (const width of [1024, 375, 1024]) {
+    await page.setViewportSize({ width, height: 900 });
+    await expect(dialog).toHaveCount(1);
+    await expect(dialog).toBeVisible();
+    await expect(dialog.getByLabel("New deck name")).toHaveValue("画面を回転しても残る調査");
+    await expect(page.locator("#new-deck-title")).toHaveCount(1);
+  }
+  await dialog.getByRole("button", { name: "Create", exact: true }).click();
+  await expect(dialog).toHaveCount(0);
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("画面を回転しても残る調査");
+});

e2e/integrations/home.test.ts

@@ -0,0 +1,113 @@
+import { expect, test } from "../fixtures";
+
+test("previews a natural-language memo and shares the executed record with journal", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await page.waitForLoadState("networkidle");
+  const memo = "明日のレビューは導線から確認する";
+  await page.getByRole("textbox", { name: "Home input" }).fill(`Note: ${memo}`);
+  await page.getByRole("button", { name: "Preview action" }).click();
+  const execute = page.getByRole("button", { name: "Apply", exact: true });
+  await expect(execute).toBeVisible();
+  await execute.click();
+  await page.getByRole("link", { name: "Journal", exact: true }).first().click();
+  await expect(page.getByRole("article", { name: "Note entry" })).toContainText(memo);
+  await page.getByRole("link", { name: "Home", exact: true }).first().click();
+  await expect(page.getByRole("textbox", { name: "Home input" })).toBeVisible();
+});
+
+test("keeps the home usable on narrow screens", async ({ page, a11y }, testInfo) => {
+  await page.goto("/");
+  await page.waitForLoadState("networkidle");
+  for (const width of [320, 375, 768]) {
+    await page.setViewportSize({ width, height: 850 });
+    await expect(page.getByRole("textbox", { name: "Home input" })).toBeVisible();
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    await page.screenshot({ path: testInfo.outputPath(`home-${width}.png`) });
+    if (width === 320) expect((await a11y().analyze()).violations).toEqual([]);
+  }
+});
+
+test("adds tasks only after confirmation and can defer and restore them", async ({ page }) => {
+  await page.goto("/");
+  await page.waitForLoadState("networkidle");
+  const input = page.getByRole("textbox", { name: "Home input" });
+  const complete = page.getByRole("button", {
+    name: "Complete grocery shopping",
+    exact: true,
+  });
+  await input.fill("Add grocery shopping");
+  await page.getByRole("button", { name: "Preview action" }).click();
+  await expect(complete).toHaveCount(0);
+  await page.getByRole("button", { name: "Apply", exact: true }).click();
+  await expect(complete).toBeVisible();
+  await input.fill("Defer grocery shopping");
+  await page.getByRole("button", { name: "Preview action" }).click();
+  await expect(complete).toBeVisible();
+  await page.getByRole("button", { name: "Apply", exact: true }).click();
+  await expect(complete).toHaveCount(0);
+  await page.locator(".home-rest summary").click();
+  await page.getByRole("button", { name: "Restore grocery shopping", exact: true }).click();
+  await complete.click();
+  await expect(complete).toHaveCount(0);
+  await page.locator(".home-rest summary").click();
+  await expect(
+    page.getByRole("button", { name: "Restore grocery shopping", exact: true }),
+  ).toBeVisible();
+});
+
+test("resolves communication within home and carries the status to the shared queue", async ({
+  page,
+  a11y,
+}) => {
+  await page.goto("/");
+  await page.waitForLoadState("networkidle");
+  await page.getByRole("button", { name: "Open conversation with Haruka Aoki" }).click();
+  const dialog = page.getByRole("dialog", {
+    name: "Conversation with Haruka Aoki",
+  });
+  await expect(dialog.getByRole("textbox", { name: "Reply", exact: true })).toBeVisible();
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await dialog.getByRole("button", { name: "Leave for later" }).click();
+  await expect(dialog).toHaveCount(0);
+  await expect(
+    page.getByRole("button", { name: "Open conversation with Haruka Aoki" }),
+  ).toHaveCount(0);
+  await page.getByRole("link", { name: "Messages", exact: true }).first().click();
+  const rows = page.locator(".support-row");
+  await expect(rows.filter({ hasText: "Schedule next week’s design review" })).toHaveCount(0);
+  await page.getByRole("button", { name: "Later", exact: true }).click();
+  await rows.filter({ hasText: "Schedule next week’s design review" }).click();
+  await page.getByRole("button", { name: "Move to Now" }).click();
+  const back = page.getByRole("button", { name: "Back to messages" });
+  if (await back.isVisible()) await back.click();
+  await page.getByRole("link", { name: "Home", exact: true }).first().click();
+  await expect(
+    page.getByRole("button", { name: "Open conversation with Haruka Aoki" }),
+  ).toBeVisible();
+});
+
+test("updates the prose brief as priorities change and opens the referenced conversation", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await page.waitForLoadState("networkidle");
+  const brief = page.getByRole("region", { name: "Daily brief" });
+  await expect(brief).toContainText("Review the documents");
+  await expect(brief).toContainText("4 conversations");
+  await page.getByRole("button", { name: "Complete Review the documents", exact: true }).click();
+  await expect(brief).not.toContainText("Review the documents");
+  await brief.getByRole("button", { name: "Reply to Haruka Aoki" }).click();
+  const dialog = page.getByRole("dialog", {
+    name: "Conversation with Haruka Aoki",
+    exact: true,
+  });
+  await dialog.getByRole("button", { name: "Leave for later" }).click();
+  await expect(brief).toContainText("3 conversations");
+  await expect(brief).not.toContainText("Haruka Aoki");
+  await page.getByRole("textbox", { name: "Home input" }).fill("再開地点：資料の2ページ目から");
+  await page.getByRole("button", { name: "Preview action" }).click();
+  await page.getByRole("button", { name: "Apply", exact: true }).click();
+  await expect(brief).toContainText("資料の2ページ目から");
+});

e2e/integrations/inbox.test.ts

@@ -0,0 +1,75 @@
+import { expect, test } from "../fixtures";
+
+test("selects articles and keeps the reader focused on their content", async ({ page }) => {
+  await page.goto("/inbox");
+  await page.waitForLoadState("networkidle");
+  const rows = page.locator(".inbox-article-row");
+  await expect(rows).toHaveCount(9);
+  const articleTitle = "Context for an agent can be brief";
+  await rows.filter({ hasText: articleTitle }).click();
+  const reader = page.getByRole("article", { name: articleTitle, exact: true });
+  await expect(reader).toBeVisible();
+  await expect(reader.getByRole("heading", { name: articleTitle, exact: true })).toBeVisible();
+  await expect(
+    reader.getByText("Start with a one-sentence goal, then add the constraints that must hold.", {
+      exact: false,
+    }),
+  ).toBeVisible();
+  await expect(page.getByText("FOR YOU", { exact: true })).toHaveCount(0);
+  await expect(page.getByText("Mock", { exact: true })).toHaveCount(0);
+  await expect(page.getByText("Why this article", { exact: true })).toHaveCount(0);
+  await expect(page.getByRole("button", { name: /For you|Read later|Unread only/ })).toHaveCount(0);
+  const back = page.getByRole("button", { name: "Back to articles" });
+  if (await back.isVisible()) await back.click();
+  await rows.filter({ hasText: "Three columns create a rhythm for reading" }).click();
+  await expect(
+    page.getByRole("article", {
+      name: "Three columns create a rhythm for reading",
+      exact: true,
+    }),
+  ).toBeVisible();
+});
+
+test("recovers from empty search and shares navigation with Research", async ({ page, a11y }) => {
+  await page.goto("/inbox");
+  await page.waitForLoadState("networkidle");
+  const rows = page.locator(".inbox-article-row");
+  await page.getByRole("textbox", { name: "Search articles" }).fill("nonexistent-query-xyz");
+  await expect(rows).toHaveCount(0);
+  await expect(page.getByText("No articles found", { exact: true })).toBeVisible();
+  await page.getByRole("button", { name: "Clear search" }).click();
+  await expect(rows).toHaveCount(9);
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await expect(page.getByRole("button", { name: "Edit interests", exact: true })).toHaveCount(0);
+  await page.getByRole("link", { name: "Research", exact: true }).click();
+  await expect(page).toHaveURL(/\/deck$/);
+  await page.getByRole("link", { name: "Reader", exact: true }).click();
+  await expect(page).toHaveURL(/\/inbox$/);
+  await expect(rows).toHaveCount(9);
+});
+
+test("keeps article navigation readable without horizontal overflow", async ({
+  page,
+  a11y,
+}, testInfo) => {
+  await page.goto("/inbox");
+  await page.waitForLoadState("networkidle");
+  for (const width of [320, 375, 414, 768]) {
+    await page.setViewportSize({ width, height: 850 });
+    await expect(page.getByRole("textbox", { name: "Search articles" })).toBeVisible();
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    await page.locator(".inbox-article-row").first().click();
+    const reader = page.getByRole("article", {
+      name: "Thinking in the browser: a new workflow with AI agents",
+      exact: true,
+    });
+    await expect(reader).toBeVisible();
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    await page.screenshot({
+      path: testInfo.outputPath(`inbox-reader-${width}.png`),
+    });
+    if (width === 320) expect((await a11y().analyze()).violations).toEqual([]);
+    const back = page.getByRole("button", { name: "Back to articles" });
+    if (await back.isVisible()) await back.click();
+  }
+});

e2e/integrations/reader.test.ts

@@ -1,176 +0,0 @@
-import { expect, test } from '../fixtures'
-
-let consoleErrors: string[]
-let pageErrors: string[]
-
-test.beforeEach(async ({ page }) => {
-  consoleErrors = []
-  pageErrors = []
-  page.on('console', (message) => {
-    if (message.type() === 'error') consoleErrors.push(message.text())
-  })
-  page.on('pageerror', (error) => pageErrors.push(error.message))
-})
-
-test.afterEach(() => {
-  expect(consoleErrors, 'browser console errors').toEqual([])
-  expect(pageErrors, 'uncaught browser errors').toEqual([])
-})
-
-test('requires intent and infinitely loads a user timeline', async ({
-  homePage,
-  page,
-  userPage,
-}) => {
-  await homePage.goTo()
-  await expect(page).toHaveURL(/\/$/)
-  await expect(homePage.articlesLocator).toHaveCount(0)
-  await expect(homePage.ambientLinksLocator).toHaveCount(0)
-
-  await homePage.displayUser('@yuta')
-
-  await expect(page).toHaveURL(/\/yuta$/)
-  await expect(page.getByText('user page 1')).toBeVisible()
-  await expect(page.getByText('user page 2')).toBeVisible()
-  await expect(userPage.endOfFeedLocator).toBeVisible()
-  await expect(page).toHaveScreenshot('mist-user.png', {
-    animations: 'disabled',
-    fullPage: true,
-  })
-})
-
-test('selects an authenticated list and infinitely loads its timeline', async ({
-  listsPage,
-  page,
-}) => {
-  await listsPage.goTo()
-  await expect(listsPage.articlesLocator).toHaveCount(0)
-
-  await listsPage.openList(/My E2E List.*10 メンバー/)
-
-  await expect(page).toHaveURL(/\/i\/lists\/1234567890$/)
-  await expect(page.getByText('list page 1')).toBeVisible()
-  await expect(page.getByText('list page 2')).toBeVisible()
-  await expect(listsPage.endOfFeedLocator).toBeVisible()
-})
-
-test('opens a card detail and infinitely loads its conversation', async ({
-  page,
-  threadPage,
-  userPage,
-}) => {
-  await userPage.goTo('yuta')
-  await userPage.openPostDetails('user page 1')
-
-  await expect(page).toHaveURL(/\/yuta\/status\/1001$/)
-  await expect(threadPage.headingLocator).toBeVisible()
-  await expect(threadPage.selectedPostLabelLocator).toBeVisible()
-  await expect(page.getByText('user page 1')).toHaveCount(1)
-  await expect(page.getByText('thread root')).toBeVisible()
-  await expect(page.getByText('thread page 1')).toBeVisible()
-  await expect(page.getByText('thread page 2')).toBeVisible()
-  await expect(threadPage.endOfFeedLocator).toBeVisible()
-  await expect(page).toHaveScreenshot('mist-thread.png', {
-    animations: 'disabled',
-    fullPage: true,
-  })
-})
-
-test('resolves a reply root and retries only the failed continuation', async ({
-  page,
-  threadPage,
-}) => {
-  await threadPage.goTo('yuta', '2001')
-
-  await expect(page.getByText('retry focal')).toHaveCount(1)
-  await expect(page.getByText('thread root')).toBeVisible()
-  await expect(page.getByText('thread page 1')).toBeVisible()
-  await expect(threadPage.continuationErrorLocator).toHaveCount(1)
-  await expect(page.getByText('retry focal')).toHaveCount(1)
-
-  await threadPage.retryContinuation()
-
-  await expect(page.getByText('thread page 2')).toBeVisible()
-  await expect(threadPage.continuationErrorLocator).toHaveCount(0)
-  await expect(threadPage.endOfFeedLocator).toBeVisible()
-  await expect(threadPage.mutationButtonsLocator).toHaveCount(0)
-})
-
-test('searches Top posts from followed accounts', async ({
-  page,
-  searchPage,
-}) => {
-  await searchPage.goTo()
-  await expect(searchPage.articlesLocator).toHaveCount(0)
-  await searchPage.searchTopFromFollowing('AI lang:ja')
-  await expect(searchPage.followingOnlyLocator).toBeChecked()
-
-  await expect(page).toHaveURL(/following=true/)
-  await expect(page.getByText('Top · follows page 1')).toBeVisible()
-  await expect(page.getByText('Top · follows page 2')).toBeVisible()
-  await expect(searchPage.endOfFeedLocator).toBeVisible()
-})
-
-test('retains the first page through a pagination error and retries explicitly', async ({
-  page,
-  searchPage,
-}, testInfo) => {
-  await searchPage.goTo()
-  await expect(searchPage.articlesLocator).toHaveCount(0)
-  await searchPage.search(`retry-${testInfo.project.name}`)
-
-  await expect(page.getByText('Latest · all page 1')).toBeVisible()
-  await expect(searchPage.continuationErrorLocator).toHaveCount(1)
-  await expect(page.getByText('Latest · all page 1')).toBeVisible()
-  await expect(page.getByText('Latest · all page 2')).toHaveCount(0)
-
-  await searchPage.retryContinuation()
-
-  await expect(page.getByText('Latest · all page 2')).toBeVisible()
-  await expect(searchPage.continuationErrorLocator).toHaveCount(0)
-  await expect(searchPage.endOfFeedLocator).toBeVisible()
-})
-
-test('keeps keyboard focus intentional and discovery or mutation controls absent', async ({
-  searchPage,
-}) => {
-  await searchPage.goTo()
-
-  await searchPage.tabTo(
-    searchPage.page.getByRole('link', { name: 'ユーザー' }),
-  )
-  await searchPage.tabTo(searchPage.page.getByRole('link', { name: '検索' }))
-  await searchPage.tabTo(searchPage.page.getByRole('link', { name: 'リスト' }))
-  await searchPage.tabTo(searchPage.queryInputLocator)
-  await expect(searchPage.latestRankingLocator).toBeChecked()
-  await searchPage.tabTo(searchPage.latestRankingLocator)
-  await searchPage.tabTo(searchPage.followingOnlyLocator)
-  await searchPage.tabTo(searchPage.searchButtonLocator)
-
-  await expect(searchPage.ambientLinksLocator).toHaveCount(0)
-  await expect(searchPage.mutationButtonsLocator).toHaveCount(0)
-  await expect(searchPage.mutationLinksLocator).toHaveCount(0)
-})
-
-test('removes loading rail animation for reduced motion', async ({
-  page,
-  searchPage,
-}, testInfo) => {
-  await page.emulateMedia({ reducedMotion: 'reduce' })
-  await searchPage.goTo()
-  await expect(searchPage.articlesLocator).toHaveCount(0)
-  await searchPage.search(`slow-${testInfo.project.name}`)
-
-  const rail = searchPage.loadingRailLocator
-  await expect(rail).toBeVisible()
-  await expect
-    .poll(() =>
-      rail.evaluate((element) =>
-        getComputedStyle(element, '::after').getPropertyValue('animation-name'),
-      ),
-    )
-    .toBe('none')
-
-  await expect(page.getByText('Latest · all page 2')).toBeVisible()
-  await expect(searchPage.endOfFeedLocator).toBeVisible()
-})

e2e/integrations/research.test.ts

@@ -0,0 +1,378 @@
+import type { DeckColumn } from "../../src/features/decks/model";
+import type { ResearchRun } from "../../src/features/research/model";
+import { expect, test } from "../fixtures";
+import { closeMobileSidebar, showDeckManagement, showResearch } from "../workspace";
+
+test("pushes the current research snapshot on each SSE connection", async ({ page }) => {
+  await page.goto("/deck");
+  const snapshots = await page.evaluate(async () => {
+    const connect = () =>
+      new Promise<unknown>((resolve, reject) => {
+        const events = new EventSource("/api/research/events");
+        const timer = setTimeout(() => {
+          events.close();
+          reject(new Error("SSE timed out"));
+        }, 5000);
+        events.onmessage = (event) => {
+          clearTimeout(timer);
+          events.close();
+          resolve(JSON.parse(event.data));
+        };
+        events.onerror = () => {
+          clearTimeout(timer);
+          events.close();
+          reject(new Error("SSE failed"));
+        };
+      });
+    return [await connect(), await connect()];
+  });
+  expect(snapshots).toEqual([
+    { configured: false, run: null, history: [] },
+    { configured: false, run: null, history: [] },
+  ]);
+});
+
+test("restores the conversation and growing temporary deck from reconnect snapshots", async ({
+  page,
+}) => {
+  await page.goto("/deck");
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Add column", exact: true }).click();
+  const accounts = page.getByRole("combobox", {
+    name: "Connection profile",
+    exact: true,
+  });
+  await accounts.selectOption({ label: "e2e" });
+  const connectionId = await accounts.inputValue();
+  await page.keyboard.press("Escape");
+  await closeMobileSidebar(page);
+  const run: ResearchRun = {
+    id: "36ad8cc7-318c-46ae-94fa-28d30336f027",
+    threadId: "conversation-test",
+    connectionIds: [connectionId],
+    topic: "既存の観点を使って調査して",
+    status: "running",
+    startedAt: Date.now(),
+    deckVersion: 1,
+    citations: [],
+    message: "既存の検索条件を再利用しています。",
+    messages: [
+      { id: "user-1", role: "user", text: "既存の観点を使って調査して" },
+      { id: "tool-1", role: "tool", text: "list_decks: 完了" },
+      {
+        id: "assistant-1",
+        role: "assistant",
+        text: "既存の検索条件を再利用しています。",
+      },
+    ],
+    deck: {
+      id: "generated-plan",
+      title: "会話からの調査",
+      columns: [
+        {
+          id: "one",
+          title: "最初の観点",
+          connectionId,
+          source: {
+            platform: "twitter",
+            kind: "search",
+            query: "WebMCP",
+            product: "Latest",
+            following: false,
+          },
+        },
+      ],
+    },
+  };
+  await page.route("**/api/research/events*", (route) =>
+    route.fulfill({
+      contentType: "text/event-stream",
+      body: `data: ${JSON.stringify({ configured: true, run })}\n\n`,
+    }),
+  );
+  await page.goto(`/deck?run=${run.id}`);
+  await showResearch(page);
+  const conversation = page.getByRole("log", { name: "Research conversation" });
+  await expect(conversation).toContainText("既存の観点を使って調査して");
+  await expect(conversation).toContainText("list_decks: 完了");
+  await expect(conversation).toContainText("既存の検索条件を再利用しています。");
+  await expect(conversation.locator('[data-slot="bubble-content"]')).not.toHaveCSS(
+    "background-color",
+    "rgba(0, 0, 0, 0)",
+  );
+  await expect(page.locator(".deck-column h2")).toHaveText(["最初の観点"]);
+  run.deckVersion = 2;
+  run.status = "complete";
+  run.messages.push({
+    id: "assistant-2",
+    role: "assistant",
+    text: "比較する観点を追加しました。",
+  });
+  run.deck?.columns.push({
+    id: "two",
+    title: "比較の観点",
+    connectionId,
+    source: {
+      platform: "twitter",
+      kind: "search",
+      query: "WebMCP lang:ja",
+      product: "Latest",
+      following: false,
+    },
+  });
+  await page.reload();
+  await showResearch(page);
+  await expect(conversation).toContainText("既存の観点を使って調査して");
+  await expect(conversation).toContainText("比較する観点を追加しました。");
+  await expect(page.locator(".deck-column h2")).toHaveText(["最初の観点", "比較の観点"]);
+  await closeMobileSidebar(page);
+  await expect(page.getByRole("button", { name: "Save as deck", exact: true })).toBeEnabled();
+  await showResearch(page);
+  const accountPicker = page.getByRole("button", {
+    name: "Connected accounts · 1",
+  });
+  await accountPicker.click();
+  await expect(accountPicker).toHaveAttribute("aria-expanded", "true");
+  await expect(page.getByRole("checkbox", { name: "e2e · Twitter" })).toBeChecked();
+  await accountPicker.click();
+  await expect(accountPicker).toHaveAttribute("aria-expanded", "false");
+  await page.getByLabel("Message", { exact: true }).fill("この観点を詳しく");
+  await expect(page.getByRole("button", { name: "Send", exact: true })).toBeEnabled();
+  await page.getByRole("button", { name: "Close sidebar", exact: true }).click();
+  run.deckVersion = 3;
+  if (run.deck) run.deck.title = "閉じている間に更新された調査";
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("閉じている間に更新された調査", {
+    timeout: 15000,
+  });
+  await showResearch(page);
+  await expect(page.getByLabel("Message", { exact: true })).toHaveValue("この観点を詳しく");
+  await page.setViewportSize({ width: 600, height: 900 });
+  await expect(page.locator('[data-sidebar="sidebar"][data-mobile="true"]')).toHaveCount(1);
+  await showResearch(page);
+  await expect(page.getByLabel("Message", { exact: true })).toHaveValue("この観点を詳しく");
+  await page.getByRole("button", { name: "Connected accounts · 1" }).click();
+  await page.getByRole("checkbox", { name: "e2e · Twitter" }).uncheck();
+  await page.setViewportSize({ width: 1100, height: 900 });
+  await expect(page.locator('[data-sidebar="sidebar"][data-mobile="true"]')).toHaveCount(0);
+  await showResearch(page);
+  await expect(page.getByLabel("Message", { exact: true })).toHaveValue("この観点を詳しく");
+  await page.getByRole("button", { name: "Connected accounts · 0" }).click();
+  await expect(page.getByRole("checkbox", { name: "e2e · Twitter" })).not.toBeChecked();
+  await page.setViewportSize({ width: 600, height: 900 });
+  await expect(page.locator('[data-sidebar="sidebar"][data-mobile="true"]')).toHaveCount(1);
+  await showResearch(page);
+  await expect(page.getByLabel("Message", { exact: true })).toHaveValue("この観点を詳しく");
+  await page.getByRole("button", { name: "Connected accounts · 0" }).click();
+  await expect(page.getByRole("checkbox", { name: "e2e · Twitter" })).not.toBeChecked();
+});
+
+test("rejects a different tailnet owner at the SSE endpoint", async ({ request }) => {
+  const response = await request.get("/api/research/events", {
+    headers: { "Tailscale-User-Login": "[email protected]" },
+  });
+  expect(response.status()).toBe(403);
+});
+
+test("renders Markdown and reveals an unloaded citation in an offscreen deck column", async ({
+  page,
+  a11y,
+}) => {
+  await page.emulateMedia({ reducedMotion: "reduce" });
+  await page.goto("/deck");
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Add column", exact: true }).click();
+  const accounts = page.getByRole("combobox", {
+    name: "Connection profile",
+    exact: true,
+  });
+  await accounts.selectOption({ label: "e2e" });
+  const connectionId = await accounts.inputValue();
+  await page.keyboard.press("Escape");
+  await closeMobileSidebar(page);
+  const source: DeckColumn = {
+    id: "citation-column-2",
+    title: "引用の観点",
+    connectionId,
+    source: {
+      platform: "twitter",
+      kind: "search",
+      query: "citation-query-2",
+      product: "Latest",
+      following: false,
+    },
+  };
+  const columns: DeckColumn[] = ["概要", "比較"].map((title, index) => ({
+    id: `citation-column-${index}`,
+    title,
+    connectionId,
+    source: {
+      platform: "twitter",
+      kind: "search",
+      query: `citation-query-${index}`,
+      product: "Latest",
+      following: false,
+    },
+  }));
+  columns.push(source);
+  const run: ResearchRun = {
+    id: "973ae084-18ed-4674-8899-c75851e51d1b",
+    topic: "引用を確認",
+    status: "complete",
+    startedAt: Date.now(),
+    deckVersion: 1,
+    message: "",
+    deck: { id: "citation-deck", title: "引用付きの調査", columns },
+    messages: [
+      {
+        id: "answer",
+        role: "assistant",
+        text: "## 調査結果\n\n**重要な発見**です。\n\n- [根拠の投稿](https://x.com/author/status/123456789?s=20)\n\n| 観点 | 結果 |\n| --- | --- |\n| 投稿 | 確認済み |\n\n`コード`も表示します。",
+      },
+    ],
+    citations: [
+      {
+        column: source,
+        post: {
+          key: "twitter:123456789",
+          nativeId: "123456789",
+          platform: "twitter",
+          url: "https://twitter.com/author/status/123456789",
+          text: "AIが調査時に取得した引用本文",
+          author: { name: "引用元の著者", handle: "author" },
+        },
+      },
+    ],
+  };
+  await page.route("**/api/research/events*", (route) =>
+    route.fulfill({
+      contentType: "text/event-stream",
+      body: `data: ${JSON.stringify({ configured: true, run })}\n\n`,
+    }),
+  );
+  await page.goto(`/deck?run=${run.id}`);
+  await showResearch(page);
+  const chat = page.getByRole("log", { name: "Research conversation" });
+  await expect(chat.getByRole("heading", { name: "調査結果" })).toBeVisible();
+  await expect(chat.getByRole("heading", { name: "調査結果" })).toHaveCSS("font-weight", "600");
+  await expect(chat.locator("ul")).toHaveCSS("list-style-type", "disc");
+  await expect(chat.locator("strong").filter({ hasText: "重要な発見" })).toBeVisible();
+  await expect(chat.getByRole("table")).toBeVisible();
+  await expect(page.getByText("AIが調査時に取得した引用本文", { exact: true })).toHaveCount(0);
+  await chat.getByRole("link", { name: "根拠の投稿" }).click();
+  const card = page.locator(
+    '.research-post[data-post-url="https://twitter.com/author/status/123456789"]',
+  );
+  await expect(card).toBeVisible();
+  await expect(card).toHaveClass(/citation-highlight/);
+  await expect(card).toBeFocused();
+  await expect(card).toContainText("Post saved during research");
+  await expect(card).toContainText("AIが調査時に取得した引用本文");
+  expect(
+    await page.locator(".deck-board").evaluate((element) => element.scrollLeft),
+  ).toBeGreaterThan(0);
+  expect(page.context().pages()).toHaveLength(1);
+  await expect(page).toHaveURL(/citation=twitter%3A123456789/);
+  const bookmarked = new URL(page.url());
+  bookmarked.searchParams.set("run", run.id);
+  bookmarked.searchParams.set("deck", "citation-deck");
+  const submitted: string[] = [];
+  page.on("request", (request) => {
+    if (request.method() === "POST") submitted.push(request.url());
+  });
+  await page.goto(bookmarked.toString());
+  await expect(card).toBeVisible();
+  await expect(card).toHaveClass(/citation-highlight/);
+  await expect(page).toHaveURL(/citation=twitter%3A123456789/);
+  await expect(page.locator(".deck-column")).toHaveCount(3);
+  expect(submitted).toEqual([]);
+  expect((await a11y().analyze()).violations).toEqual([]);
+});
+
+test("explains unconfigured Codex and prevents starting research without affecting the deck", async ({
+  page,
+  a11y,
+}) => {
+  await page.goto("/deck");
+  const heading = page.getByRole("heading", { level: 1 });
+  await expect(heading).toBeVisible();
+  const originalTitle = await heading.textContent();
+  await showResearch(page);
+  const panel = page.getByRole("complementary", { name: "Research chat" });
+  await expect(panel).toBeVisible();
+  await expect(
+    panel.getByText("The connection to Codex on your home server is not configured."),
+  ).toBeVisible();
+  await expect(panel.getByRole("button", { name: "Send", exact: true })).toBeDisabled();
+  await expect(panel.getByLabel("Message", { exact: true })).toBeDisabled();
+  const accessibility = await a11y().analyze();
+  expect(accessibility.violations).toEqual([]);
+  await closeMobileSidebar(page);
+  await expect(heading).toHaveText(originalTitle ?? "");
+  await showDeckManagement(page);
+  await page.getByRole("button", { name: "Create deck", exact: true }).click();
+  await page.getByLabel("New deck name").fill("手動の調査");
+  await page.getByRole("button", { name: "Create", exact: true }).click();
+  await closeMobileSidebar(page);
+  await expect(heading).toHaveText("手動の調査");
+  await showResearch(page);
+  await expect(panel).toBeVisible();
+});
+
+test("keeps browser conversation selection independent and restores it on reload", async ({
+  page,
+  browser,
+  context,
+}) => {
+  const { openDatabase } = await import("../../src/features/storage/database.server");
+  const { createResearchStore } = await import("../../src/features/research/repository.server");
+  const db = openDatabase(process.env.TWITTER_LITE_E2E_DB_PATH ?? "");
+  const store = createResearchStore(db);
+  const first = crypto.randomUUID();
+  const second = crypto.randomUUID();
+  for (const [id, text] of [
+    [first, "Browser one conversation"],
+    [second, "Browser two conversation"],
+  ] as const) {
+    store.save({
+      id,
+      topic: text,
+      status: "complete",
+      startedAt: Date.now(),
+      deckVersion: 0,
+      message: text,
+      messages: [{ id: `${id}-message`, role: "assistant", text }],
+      citations: [],
+    });
+  }
+  const other = await browser.newContext({
+    storageState: await context.storageState(),
+    extraHTTPHeaders: { "Tailscale-User-Login": "[email protected]" },
+  });
+  try {
+    const secondPage = await other.newPage();
+    await page.goto(`/deck?run=${first}`, { waitUntil: "domcontentloaded" });
+    await showResearch(page);
+    await secondPage.goto(`/deck?run=${second}`, {
+      waitUntil: "domcontentloaded",
+    });
+    await showResearch(secondPage);
+    await expect(page.getByRole("log", { name: "Research conversation" })).toContainText(
+      "Browser one conversation",
+    );
+    await expect(secondPage.getByRole("log", { name: "Research conversation" })).toContainText(
+      "Browser two conversation",
+    );
+    await secondPage.getByRole("button", { name: "New chat", exact: true }).click();
+    await expect(secondPage).toHaveURL(/run=new/);
+    await page.reload({ waitUntil: "domcontentloaded" });
+    await showResearch(page);
+    await expect(page).toHaveURL(new RegExp(`run=${first}`));
+    await expect(page.getByRole("log", { name: "Research conversation" })).toContainText(
+      "Browser one conversation",
+    );
+  } finally {
+    await other.close();
+    db.$client.prepare("DELETE FROM research_sessions WHERE id IN (?, ?)").run(first, second);
+    db.$client.close();
+  }
+});

e2e/integrations/support.test.ts

@@ -0,0 +1,127 @@
+import { expect, test } from "../fixtures";
+
+const reviewSubject = "Schedule next week’s design review";
+const coffeeSubject = "Catch up over coffee";
+
+test("reviews an edited reply and keeps the simulated result in history", async ({
+  page,
+  a11y,
+}) => {
+  await page.goto("/support");
+  await page.waitForLoadState("networkidle");
+  const rows = page.locator(".support-row");
+  await expect(rows).toHaveCount(3);
+  await rows.filter({ hasText: reviewSubject }).click();
+  await page.getByRole("button", { name: "Polite", exact: true }).click();
+  const reply = page.getByRole("textbox", { name: "Reply", exact: true });
+  await expect(reply).toHaveValue(/Thank you for sharing/);
+  const edited = "I reviewed the materials. Let’s discuss the first-time experience.";
+  await reply.fill(edited);
+  const slot = "Mon, Oct 5, 14:00–14:30";
+  await page.getByRole("combobox", { name: "Suggested times" }).selectOption(slot);
+  await page.getByRole("button", { name: "Add to reply" }).click();
+  await expect(reply).toHaveValue(`${edited}\n\nWould ${slot} work for you?`);
+  await page.getByRole("button", { name: "Review reply" }).click();
+  const dialog = page.getByRole("dialog", { name: "Review reply" });
+  await expect(dialog).toContainText(edited);
+  await expect(dialog).toContainText(slot);
+  await expect(dialog).toContainText("No message will be sent");
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await dialog.getByRole("button", { name: "Back", exact: true }).click();
+  await expect(reply).toHaveValue(new RegExp(edited));
+  await page.getByRole("button", { name: "Review reply" }).click();
+  await dialog.getByRole("button", { name: "Try sending" }).click();
+  await expect(dialog).toHaveCount(0);
+  await expect(rows.filter({ hasText: reviewSubject })).toHaveCount(0);
+  await page.getByRole("button", { name: "History", exact: true }).click();
+  await rows.filter({ hasText: reviewSubject }).click();
+  await expect(page.locator(".support-outcome")).toContainText(edited);
+  await expect(page.locator(".support-outcome")).toContainText(slot);
+});
+
+test("defers a conversation and restores it to the current queue", async ({ page }) => {
+  await page.goto("/support");
+  await page.waitForLoadState("networkidle");
+  const rows = page.locator(".support-row");
+  await rows.filter({ hasText: coffeeSubject }).click();
+  await page
+    .getByRole("textbox", { name: "Reply", exact: true })
+    .fill("土曜の予定を確認してから返事するね。");
+  await page.getByRole("button", { name: "Leave for later" }).click();
+  await expect(rows.filter({ hasText: coffeeSubject })).toHaveCount(0);
+  await page.getByRole("button", { name: "Later", exact: true }).click();
+  await rows.filter({ hasText: coffeeSubject }).click();
+  await expect(page.getByRole("textbox", { name: "Reply", exact: true })).toHaveValue(
+    "土曜の予定を確認してから返事するね。",
+  );
+  await page.getByRole("button", { name: "Move to Now" }).click();
+  const back = page.getByRole("button", { name: "Back to messages" });
+  if (await back.isVisible()) await back.click();
+  await expect(rows.filter({ hasText: coffeeSubject })).toBeVisible();
+  await expect(page.getByRole("button", { name: "Now", exact: true })).toHaveAttribute(
+    "aria-pressed",
+    "true",
+  );
+});
+
+test("keeps corrections as new records and summarizes only selected current facts", async ({
+  page,
+  a11y,
+}) => {
+  await page.goto("/journal");
+  await page.waitForLoadState("networkidle");
+  await expect(page.getByRole("button", { name: "Save entry", exact: true })).toBeDisabled();
+  await page.getByRole("textbox", { name: "Entry text" }).fill("次はレビュー資料の導線を確認する");
+  await page.getByRole("button", { name: "Save entry", exact: true }).click();
+  await expect(page.getByRole("article", { name: "Note entry" })).toContainText(
+    "Occurred: Unknown",
+  );
+  await page.getByRole("button", { name: "Weight", exact: true }).click();
+  await page.getByRole("spinbutton", { name: "Weight", exact: true }).fill("65.2");
+  await page.getByRole("textbox", { name: "Source" }).fill("自宅の体重計");
+  await page.getByRole("button", { name: "Save entry", exact: true }).click();
+  await page
+    .getByRole("article", { name: "Weight entry" })
+    .getByRole("button", { name: "Correct" })
+    .click();
+  const correction = page.getByRole("dialog", { name: "Correct entry" });
+  await correction.getByRole("spinbutton", { name: "Weight", exact: true }).fill("65.8");
+  await correction.getByRole("button", { name: "Add correction" }).click();
+  const weights = page.getByRole("article", { name: "Weight entry" });
+  await expect(weights).toHaveCount(2);
+  await expect(weights.filter({ hasText: "65.2 kg" })).toContainText("Original");
+  await expect(weights.filter({ hasText: "65.8 kg" })).toContainText("Correction");
+  await page.getByRole("button", { name: "Summarize entries", exact: true }).click();
+  const review = page.getByRole("dialog", { name: "Summarize entries" });
+  const summary = review.getByRole("textbox", { name: "Entry summary" });
+  await expect(summary).toHaveValue(/65.8 kg/);
+  await expect(summary).not.toHaveValue(/65.2 kg/);
+  await expect(summary).toHaveValue(/Source: 自宅の体重計/);
+  await expect(summary).toHaveValue(/Entries with an unknown event time: 2 entries/);
+  await review.getByRole("checkbox", { name: /次はレビュー資料/ }).uncheck();
+  await expect(summary).not.toHaveValue(/次はレビュー資料/);
+  await expect(summary).toHaveValue(
+    /Medication and weight are unknown for periods without entries/,
+  );
+  expect((await a11y().analyze()).violations).toEqual([]);
+});
+
+test("fits communication and journal interactions in narrow screens", async ({ page, a11y }) => {
+  for (const width of [320, 375, 768]) {
+    await page.setViewportSize({ width, height: 850 });
+    await page.goto("/support");
+    await page.waitForLoadState("networkidle");
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    await page.locator(".support-row").first().click();
+    await expect(page.getByRole("textbox", { name: "Reply", exact: true })).toBeVisible();
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    if (width === 320) expect((await a11y().analyze()).violations).toEqual([]);
+    const back = page.getByRole("button", { name: "Back to messages" });
+    if (await back.isVisible()) await back.click();
+    await page.getByRole("link", { name: "Journal", exact: true }).click();
+    await page.getByRole("button", { name: "Weight", exact: true }).click();
+    await expect(page.getByRole("spinbutton", { name: "Weight", exact: true })).toBeVisible();
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    if (width === 320) expect((await a11y().analyze()).violations).toEqual([]);
+  }
+});

e2e/integrations/url-state.test.ts

@@ -0,0 +1,106 @@
+import { expect, test } from "../fixtures";
+
+test("restores article selection with browser history and reload", async ({ page }) => {
+  await page.goto("/inbox", { waitUntil: "networkidle" });
+  const rows = page.locator(".inbox-article-row");
+  const heading = await rows.nth(1).locator(".inbox-row-title").innerText();
+  await rows.nth(1).click();
+  await expect(page.locator(".inbox-article-title")).toHaveText(heading);
+  const selectedUrl = page.url();
+  expect(new URL(selectedUrl).searchParams.get("article")).toBeTruthy();
+  await page.reload({ waitUntil: "networkidle" });
+  await expect(page.locator(".inbox-article-title")).toHaveText(heading ?? "");
+  await page.goBack();
+  await expect(page.locator(".inbox-workspace")).toHaveAttribute("data-reading", "false");
+  await page.goForward();
+  await expect(page).toHaveURL(selectedUrl);
+  await expect(page.locator(".inbox-article-title")).toHaveText(heading ?? "");
+});
+
+test("restores search and replaces typing history", async ({ page }) => {
+  await page.goto("/", { waitUntil: "networkidle" });
+  await page.getByRole("link", { name: "Reader", exact: true }).click();
+  const search = page.getByRole("textbox", { name: "Search articles" });
+  await search.pressSequentially("browser");
+  await expect(search).toHaveValue("browser");
+  await expect.poll(() => new URL(page.url()).searchParams.get("q")).toBe("browser");
+  const count = await page.locator(".inbox-article-row").count();
+  await page.reload({ waitUntil: "networkidle" });
+  await expect(search).toHaveValue("browser");
+  await expect(page.locator(".inbox-article-row")).toHaveCount(count);
+  await page.goBack();
+  await expect(page).toHaveURL("http://127.0.0.1:4173/");
+});
+
+test("restores account dialog without losing underlying article", async ({ page }) => {
+  await page.goto("/inbox", { waitUntil: "networkidle" });
+  await page.getByRole("button", { name: "Manage connected accounts" }).click();
+  await expect.poll(() => new URL(page.url()).searchParams.get("accounts")).toBe("true");
+  await page.reload({ waitUntil: "networkidle" });
+  await expect(page.getByRole("dialog")).toBeVisible();
+  await page.goBack();
+  await expect(page.getByRole("dialog")).toHaveCount(0);
+  await page.goForward();
+  await expect(page.getByRole("dialog")).toBeVisible();
+});
+
+test("restores a message view and conversation from its URL", async ({ page }) => {
+  await page.goto("/support", { waitUntil: "networkidle" });
+  await page.getByRole("button", { name: "All", exact: true }).click();
+  const row = page.locator(".support-row").nth(1);
+  const heading = await row.locator("span").first().innerText();
+  await row.click();
+  await expect(page.locator(".support-toolbar > span").first()).toHaveText(heading);
+  const url = page.url();
+  expect(new URL(url).searchParams.get("view")).toBe("all");
+  expect(new URL(url).searchParams.get("conversation")).toBeTruthy();
+  await page.reload({ waitUntil: "networkidle" });
+  await expect(page.locator(".support-toolbar > span").first()).toHaveText(heading ?? "");
+  await expect(page.locator(".support-workspace")).toHaveAttribute("data-reading", "true");
+});
+
+test("keeps a deep link through login", async ({ page, context }) => {
+  await context.clearCookies();
+  await page.goto("/inbox?q=browser", { waitUntil: "networkidle" });
+  await expect(page).toHaveURL(/\/login\?returnTo=/);
+  await page.getByLabel("Email address").fill("[email protected]");
+  await page.getByLabel("Password", { exact: true }).fill("E2E-only-passphrase-2026");
+  await page.getByRole("button", { name: "Sign in", exact: true }).click();
+  await expect(page).toHaveURL(/\/inbox\?q=browser$/);
+  await expect(page.getByRole("textbox", { name: "Search articles" })).toHaveValue("browser");
+});
+
+test("debounces search and cancels pending input on history navigation", async ({ page }) => {
+  await page.goto("/support", { waitUntil: "networkidle" });
+  await page.getByRole("button", { name: "All", exact: true }).click();
+  await expect(page).toHaveURL(/view=all/);
+  await page.clock.install();
+  const input = page.getByRole("textbox", { name: "Search messages" });
+  await input.fill("not-committed");
+  await expect(input).toHaveValue("not-committed");
+  expect(new URL(page.url()).searchParams.has("q")).toBe(false);
+  await page.clock.runFor(200);
+  expect(new URL(page.url()).searchParams.has("q")).toBe(false);
+  await page.goBack();
+  await expect(page).toHaveURL("http://127.0.0.1:4173/support");
+  await page.clock.runFor(400);
+  await expect(input).toHaveValue("");
+  expect(new URL(page.url()).searchParams.has("q")).toBe(false);
+  await input.fill("final search");
+  await page.clock.runFor(300);
+  await expect.poll(() => new URL(page.url()).searchParams.get("q")).toBe("final search");
+});
+
+test("waits for IME composition to finish before searching", async ({ page }) => {
+  await page.goto("/inbox", { waitUntil: "networkidle" });
+  await page.clock.install();
+  const input = page.getByRole("textbox", { name: "Search articles" });
+  await input.dispatchEvent("compositionstart");
+  await input.fill("browser");
+  await page.clock.runFor(1000);
+  await expect(input).toHaveValue("browser");
+  expect(new URL(page.url()).searchParams.has("q")).toBe(false);
+  await input.dispatchEvent("compositionend", { data: "browser" });
+  await page.clock.runFor(300);
+  await expect.poll(() => new URL(page.url()).searchParams.get("q")).toBe("browser");
+});

e2e/integrations/vitals.test.ts

@@ -0,0 +1,124 @@
+import { expect, test } from "../fixtures";
+
+test("filters body systems and opens lab history", async ({ page, a11y }) => {
+  await page.goto("/vitals");
+  await page.waitForLoadState("networkidle");
+  await expect(page.getByRole("heading", { name: "Body", exact: true })).toBeVisible();
+  const systems = page.locator(".vital-system-card");
+  await expect(systems).toHaveCount(8);
+  await page
+    .getByRole("group", { name: "Body systems", exact: true })
+    .getByRole("button", { name: "Cardiovascular", exact: true })
+    .click();
+  await expect(systems).toHaveCount(1);
+  await expect(page).toHaveURL(/vitalTab=Cardiovascular/);
+  await page.reload();
+  await page.waitForLoadState("networkidle");
+  await expect(systems).toHaveCount(1);
+  await systems.first().click();
+  const dialog = page.getByRole("dialog", { name: "Cardiovascular" });
+  await expect(dialog).toContainText("68");
+  await page.goBack();
+  await expect(dialog).not.toBeVisible();
+  await page.goForward();
+  await expect(dialog).toBeVisible();
+  await dialog.getByRole("button", { name: "Close", exact: true }).last().click();
+  await page.getByRole("button", { name: "Lab history", exact: true }).click();
+  await expect(page.locator(".vital-history")).toContainText("Jul 28");
+  await expect(page.locator(".vital-history")).toContainText("93");
+  await page.reload();
+  await page.waitForLoadState("networkidle");
+  await expect(page.locator(".vital-history")).toContainText("Jul 28");
+  await page.getByRole("button", { name: "Systems", exact: true }).click();
+  await page
+    .getByRole("group", { name: "Body systems", exact: true })
+    .getByRole("button", { name: "Overview", exact: true })
+    .click();
+  await expect(systems).toHaveCount(8);
+  expect((await a11y().analyze()).violations).toEqual([]);
+});
+
+test("explores environment charts and simulated climate controls", async ({ page, a11y }) => {
+  await page.goto("/vitals");
+  await page.waitForLoadState("networkidle");
+  const menu = page.getByRole("button", { name: "Open Health menu" });
+  if (await menu.isVisible()) await menu.click();
+  await page
+    .getByRole("complementary", { name: "Health navigation" })
+    .getByRole("button", { name: "Environment", exact: true })
+    .click();
+  await expect(page.getByRole("heading", { name: "Environment", exact: true })).toBeVisible();
+  await page.getByRole("button", { name: "7D", exact: true }).click();
+  await page
+    .getByRole("group", { name: "Trend metric" })
+    .getByRole("button", { name: "CO₂", exact: true })
+    .click();
+  await expect(
+    page.getByRole("img", { name: "7D CO₂ simulated environmental readings" }),
+  ).toBeVisible();
+  await page.reload();
+  await page.waitForLoadState("networkidle");
+  await expect(
+    page.getByRole("img", { name: "7D CO₂ simulated environmental readings" }),
+  ).toBeVisible();
+  await page.locator(".vital-metric").filter({ hasText: "Room temperature" }).click();
+  const dialog = page.getByRole("dialog", { name: "Room temperature" });
+  await expect(dialog).toContainText("64.0");
+  await page.reload();
+  await page.waitForLoadState("networkidle");
+  await expect(dialog).toContainText("64.0");
+  await dialog.getByRole("button", { name: "Back to overview" }).click();
+  await page.getByRole("button", { name: "Sync now", exact: true }).click();
+  await expect(
+    page.getByRole("status").filter({ hasText: "Sample readings refreshed" }),
+  ).toBeVisible();
+  expect((await a11y().analyze()).violations).toEqual([]);
+  await page.getByRole("button", { name: "Climate control", exact: true }).click();
+  await page.getByRole("button", { name: "Cool", exact: true }).click();
+  await expect(page.getByRole("button", { name: "Cool", exact: true })).toHaveAttribute(
+    "aria-pressed",
+    "true",
+  );
+  const temperature = page.getByRole("slider", { name: "Target temperature" });
+  await temperature.focus();
+  await temperature.press("ArrowRight");
+  await expect(temperature).toHaveValue("69");
+  await page.getByRole("button", { name: "Air purifier · On" }).click();
+  await expect(page.getByRole("button", { name: "Air purifier · Off" })).toHaveAttribute(
+    "aria-pressed",
+    "false",
+  );
+  await page.reload();
+  await page.waitForLoadState("networkidle");
+  await expect(temperature).toHaveValue("68");
+  await expect(page.getByRole("button", { name: "Auto", exact: true })).toHaveAttribute(
+    "aria-pressed",
+    "true",
+  );
+  await expect(page.getByRole("button", { name: "Air purifier · On" })).toHaveAttribute(
+    "aria-pressed",
+    "true",
+  );
+});
+
+test("keeps both dashboards within the viewport", async ({ page }, testInfo) => {
+  await page.goto("/vitals");
+  await page.waitForLoadState("networkidle");
+  for (const width of [375, 768, 1440]) {
+    await page.setViewportSize({ width, height: 1000 });
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    await page.screenshot({ path: testInfo.outputPath(`body-${width}.png`) });
+    const menu = page.getByRole("button", { name: "Open Health menu" });
+    if (await menu.isVisible()) await menu.click();
+    const navigation = page.getByRole("complementary", {
+      name: "Health navigation",
+    });
+    await navigation.getByRole("button", { name: "Environment", exact: true }).click();
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    await page.screenshot({
+      path: testInfo.outputPath(`environment-${width}.png`),
+    });
+    if (await menu.isVisible()) await menu.click();
+    await navigation.getByRole("button", { name: "Body", exact: true }).click();
+  }
+});

e2e/integrations/webmcp.test.ts

@@ -0,0 +1,283 @@
+import type { Page } from "@playwright/test";
+import Database from "better-sqlite3";
+import { expect, test } from "../fixtures";
+
+type NativeTesting = {
+  listTools(): { name: string }[];
+  executeTool(name: string, input: string): Promise<string | null>;
+};
+type ToolResult = {
+  content: { type: string; text: string }[];
+  isError?: boolean;
+};
+test.use({
+  launchOptions: {
+    executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE,
+    args: ["--enable-blink-features=WebMCP,WebMCPTesting"],
+  },
+});
+async function toolNames(page: Page) {
+  return page.evaluate(() =>
+    (navigator as Navigator & { modelContextTesting: NativeTesting }).modelContextTesting
+      .listTools()
+      .map((tool) => tool.name)
+      .sort(),
+  );
+}
+async function executeTool(
+  page: Page,
+  name: string,
+  input: Record<string, unknown> = {},
+): Promise<ToolResult> {
+  const result = await page.evaluate(
+    ({ name, input }) =>
+      (
+        navigator as Navigator & { modelContextTesting: NativeTesting }
+      ).modelContextTesting.executeTool(name, JSON.stringify(input)),
+    { name, input },
+  );
+  expect(result).not.toBeNull();
+  return JSON.parse(result ?? "{}");
+}
+function decoded(result: ToolResult) {
+  return JSON.parse(result.content[0]?.text ?? "{}");
+}
+const column = (title: string, connectionId: string) => ({
+  title,
+  connectionId,
+  source: { kind: "search", query: "WebMCP" },
+});
+function savedCount() {
+  const db = new Database(process.env.TWITTER_LITE_E2E_DB_PATH ?? "", {
+    readonly: true,
+  });
+  try {
+    return db.prepare("SELECT count(*) AS count FROM decks").get();
+  } finally {
+    db.close();
+  }
+}
+let accounts: Record<string, string>;
+let pageErrors: string[];
+test.beforeEach(async ({ page }) => {
+  pageErrors = [];
+  page.on("pageerror", (error) => pageErrors.push(error.message));
+  await page.goto("/deck");
+  await expect
+    .poll(() => toolNames(page))
+    .toEqual([
+      "delete_deck",
+      "get_column_posts",
+      "get_deck",
+      "list_connections",
+      "list_decks",
+      "load_more_column",
+      "save_deck",
+      "select_deck",
+      "set_deck",
+    ]);
+  await expect
+    .poll(async () => decoded(await executeTool(page, "list_connections")).connections?.length)
+    .toBe(2);
+  accounts = Object.fromEntries(
+    decoded(await executeTool(page, "list_connections")).connections.map(
+      (connection: { displayName: string; id: string }) => [connection.displayName, connection.id],
+    ),
+  );
+});
+test.afterEach(() => expect(pageErrors).toEqual([]));
+
+test("creates temporary research, edits it, persists explicitly and reopens it on another device", async ({
+  page,
+  browser,
+  baseURL,
+}) => {
+  const created = await executeTool(page, "set_deck", {
+    title: "WebMCPの反応",
+    columns: [
+      { ...column("日本語", accounts.e2e ?? ""), id: "new" },
+      column("別の接続", accounts.alternate ?? ""),
+    ],
+  });
+  expect(created.isError).not.toBe(true);
+  const deck = decoded(created).deck;
+  expect(deck.persisted).toBe(false);
+  expect(savedCount()).toEqual({ count: 0 });
+  await expect(page.getByText("alternate · Latest · all page 1", { exact: true })).toBeVisible();
+  await page
+    .getByRole("region", { name: "日本語", exact: true })
+    .getByRole("button", { name: "Actions for 日本語" })
+    .click();
+  await page.getByRole("menuitem", { name: "Edit", exact: true }).click();
+  const replaced = await executeTool(page, "set_deck", {
+    deckId: deck.id,
+    title: "更新した調査",
+    columns: [deck.columns[1]],
+  });
+  expect(replaced.isError).not.toBe(true);
+  await expect(page.getByRole("dialog")).toHaveCount(0);
+  expect(savedCount()).toEqual({ count: 0 });
+  expect((await executeTool(page, "save_deck", { deckId: deck.id })).isError).not.toBe(true);
+  expect((await executeTool(page, "save_deck", { deckId: deck.id })).isError).not.toBe(true);
+  expect(savedCount()).toEqual({ count: 1 });
+  const other = await browser.newContext({
+    storageState: await page.context().storageState(),
+    baseURL,
+    extraHTTPHeaders: { "Tailscale-User-Login": "[email protected]" },
+  });
+  try {
+    const device = await other.newPage();
+    await device.goto("/deck");
+    await expect(device.getByRole("heading", { level: 1 })).toHaveText("更新した調査");
+    await expect(
+      device.getByText("alternate · Latest · all page 1", { exact: true }),
+    ).toBeVisible();
+  } finally {
+    await other.close();
+  }
+  await page.reload();
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("更新した調査");
+});
+
+test("requires revisions for saved mutations and rejects stale overwrites", async ({ page }) => {
+  const deck = decoded(
+    await executeTool(page, "set_deck", { title: "保存済み", columns: [] }),
+  ).deck;
+  await executeTool(page, "save_deck", { deckId: deck.id });
+  expect(
+    (
+      await executeTool(page, "set_deck", {
+        deckId: deck.id,
+        title: "変更",
+        columns: [],
+      })
+    ).isError,
+  ).toBe(true);
+  expect(
+    (
+      await executeTool(page, "set_deck", {
+        deckId: deck.id,
+        expectedRevision: 1,
+        title: "変更",
+        columns: [],
+      })
+    ).isError,
+  ).not.toBe(true);
+  expect(
+    (
+      await executeTool(page, "set_deck", {
+        deckId: deck.id,
+        expectedRevision: 1,
+        title: "古い変更",
+        columns: [],
+      })
+    ).isError,
+  ).toBe(true);
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("変更");
+  expect(
+    (
+      await executeTool(page, "delete_deck", {
+        deckId: deck.id,
+        expectedRevision: 1,
+      })
+    ).isError,
+  ).toBe(true);
+  expect(
+    (
+      await executeTool(page, "delete_deck", {
+        deckId: deck.id,
+        expectedRevision: 2,
+      })
+    ).isError,
+  ).not.toBe(true);
+  expect(savedCount()).toEqual({ count: 0 });
+});
+
+test("keeps temporary views independent and loses only unsaved views on reload", async ({
+  page,
+}) => {
+  const first = decoded(
+    await executeTool(page, "set_deck", { title: "一時の調査A", columns: [] }),
+  ).deck;
+  const second = decoded(
+    await executeTool(page, "set_deck", { title: "一時の調査B", columns: [] }),
+  ).deck;
+  await executeTool(page, "select_deck", { deckId: first.id });
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("一時の調査A");
+  await executeTool(page, "delete_deck", { deckId: second.id });
+  expect(
+    decoded(await executeTool(page, "list_decks")).decks.some(
+      (deck: { id: string }) => deck.id === second.id,
+    ),
+  ).toBe(false);
+  expect(savedCount()).toEqual({ count: 0 });
+  await page.reload();
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("New research");
+});
+
+test("rejects invalid input without changing the active view", async ({ page }) => {
+  await executeTool(page, "set_deck", {
+    title: "残す調査",
+    columns: [column("残す観点", accounts.e2e ?? "")],
+  });
+  const duplicate = { ...column("不正", accounts.e2e ?? ""), id: "duplicate" };
+  for (const columns of [
+    [duplicate, duplicate],
+    [column("不明", "missing")],
+    [
+      {
+        ...column("不正", accounts.e2e ?? ""),
+        source: { kind: "list", target: "invalid" },
+      },
+    ],
+  ]) {
+    expect((await executeTool(page, "set_deck", { title: "変更しない", columns })).isError).toBe(
+      true,
+    );
+    await expect(page.locator(".deck-column h2")).toHaveText(["残す観点"]);
+  }
+  expect(savedCount()).toEqual({ count: 0 });
+});
+
+test("keeps failed temporary saves visible and allows retry without duplicate decks", async ({
+  page,
+}) => {
+  const deck = decoded(
+    await executeTool(page, "set_deck", { title: "未保存の調査", columns: [] }),
+  ).deck;
+  await page.route("**/_serverFn/**", (route) =>
+    route.request().method() === "POST" ? route.abort() : route.continue(),
+  );
+  expect((await executeTool(page, "save_deck", { deckId: deck.id })).isError).toBe(true);
+  await expect(page.getByRole("heading", { level: 1 })).toHaveText("未保存の調査");
+  expect(decoded(await executeTool(page, "get_deck")).deck.persisted).toBe(false);
+  await page.unroute("**/_serverFn/**");
+  expect((await executeTool(page, "save_deck", { deckId: deck.id })).isError).not.toBe(true);
+  expect(savedCount()).toEqual({ count: 1 });
+});
+
+test("reads and pages bound accounts without mixing sibling columns", async ({ page }) => {
+  const deck = decoded(
+    await executeTool(page, "set_deck", {
+      title: "接続を比較",
+      columns: [column("通常", accounts.e2e ?? ""), column("別の接続", accounts.alternate ?? "")],
+    }),
+  ).deck;
+  await expect(page.getByText("alternate · Latest · all page 1", { exact: true })).toBeVisible();
+  const id = deck.columns[1].id;
+  const loaded = decoded(await executeTool(page, "get_column_posts", { columnId: id }));
+  expect(loaded.column.connectionId).toBe(accounts.alternate);
+  expect(loaded.posts.map((post: { text: string }) => post.text)).toEqual([
+    "alternate · Latest · all page 1",
+  ]);
+  const more = decoded(await executeTool(page, "load_more_column", { columnId: id }));
+  expect(more).toMatchObject({ loadedCount: 2, offset: 1, hasMore: false });
+  expect(more.posts.map((post: { text: string }) => post.text)).toEqual([
+    "alternate · Latest · all page 2",
+  ]);
+  await expect(
+    page.getByRole("region", { name: "通常", exact: true }).locator("article"),
+  ).toHaveCount(1);
+  await executeTool(page, "set_deck", { title: "別の一時ビュー", columns: [] });
+  expect((await executeTool(page, "get_column_posts", { columnId: id })).isError).toBe(true);
+});

e2e/integrations/workspace.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from "../fixtures";
+import { closeMobileSidebar, showResearch } from "../workspace";
+
+test("keeps the sidebar, composer and deck reachable at compact widths", async ({
+  page,
+  a11y,
+}, testInfo) => {
+  await page.goto("/deck");
+  for (const width of [320, 375, 414, 768]) {
+    await page.setViewportSize({ width, height: 850 });
+    await showResearch(page);
+    const chat = page.getByRole("complementary", { name: "Research chat" });
+    await expect(chat).toBeVisible();
+    const composer = chat.getByRole("textbox", {
+      name: "Message",
+      exact: true,
+    });
+    await expect(composer).toBeVisible();
+    const bounds = await composer.boundingBox();
+    if (!bounds) throw new Error("Composer must have a visible bounding box");
+    expect(bounds.x).toBeGreaterThanOrEqual(0);
+    expect(bounds.x + bounds.width).toBeLessThanOrEqual(width);
+    expect(bounds.y + bounds.height).toBeLessThanOrEqual(850);
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(width);
+    await page.screenshot({
+      path: testInfo.outputPath(`workspace-${width}.png`),
+    });
+    if (width === 320) expect((await a11y().analyze()).violations).toEqual([]);
+    await closeMobileSidebar(page);
+  }
+  await page.getByRole("button", { name: "Toggle sidebar" }).click();
+  await expect(page.getByRole("complementary", { name: "Research chat" })).toBeHidden();
+  await page.getByRole("button", { name: "Research chat", exact: true }).click();
+  await expect(page.getByRole("complementary", { name: "Research chat" })).toBeVisible();
+});

e2e/mock-relay.mjs

@@ -1,53 +1,51 @@
-import { createServer } from 'node:http'
+import { createServer } from "node:http";
+import { tweetLegacyFixture } from "./fixtures/twitter.ts";
 
-const portValue = process.env.TWITTER_LITE_MOCK_RELAY_PORT
-const port = Number(portValue)
+const portValue = process.env.TWITTER_LITE_MOCK_RELAY_PORT;
+const port = Number(portValue);
 
 if (!portValue || !Number.isInteger(port) || port < 1) {
-  throw new Error('TWITTER_LITE_MOCK_RELAY_PORT must be a valid port')
+  throw new Error("TWITTER_LITE_MOCK_RELAY_PORT must be a valid port");
 }
 
-const failedRetryQueries = new Set()
+const failedRetryQueries = new Set();
 const rootByTarget = new Map([
-  ['1001', '1000'],
-  ['2001', '2000'],
-])
+  ["1001", "1000"],
+  ["2001", "2000"],
+  ["3001", "3000"],
+]);
 const targetByRoot = new Map([
-  ['1000', '1001'],
-  ['2000', '2001'],
-])
-const failedThreadRoots = new Set()
+  ["1000", "1001"],
+  ["2000", "2001"],
+  ["3000", "3001"],
+]);
+const failedThreadRoots = new Set();
 
-const isRecord = (value) =>
-  value !== null && typeof value === 'object' && !Array.isArray(value)
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 
 const tweetResult = (
   id,
   text,
-  username = 'yuta',
-  { conversationId = id, inReplyTo } = {},
+  username = "yuta",
+  { conversationId = id, inReplyTo, replyCount = 1 } = {},
 ) => ({
   rest_id: id,
-  legacy: {
-    full_text: text,
-    created_at: 'Mon Jul 13 00:00:00 +0000 2026',
-    reply_count: 1,
-    retweet_count: 2,
-    favorite_count: 3,
-    conversation_id_str: conversationId,
-    ...(inReplyTo ? { in_reply_to_status_id_str: inReplyTo } : {}),
-  },
+  legacy: tweetLegacyFixture(id, text, {
+    conversationId,
+    inReplyTo,
+    replyCount,
+  }),
   core: {
     user_results: {
       result: {
-        rest_id: '42',
-        legacy: { screen_name: username, name: 'Yuta' },
+        rest_id: "42",
+        legacy: { screen_name: username, name: "Yuta" },
       },
     },
   },
-})
+});
 
-const tweet = (id, text, username = 'yuta', options) => ({
+const tweet = (id, text, username = "yuta", options) => ({
   entryId: `tweet-${id}`,
   content: {
     itemContent: {
@@ -56,141 +54,140 @@ const tweet = (id, text, username = 'yuta', options) => ({
       },
     },
   },
-})
+});
 
 const cursor = (value) => ({
-  entryId: 'cursor-bottom',
-  content: { cursorType: 'Bottom', value },
-})
+  entryId: "cursor-bottom",
+  content: { cursorType: "Bottom", value },
+});
 
 const send = (response, payload, status = 200, headers = {}) => {
   response.writeHead(status, {
-    'content-type': 'application/json; charset=utf-8',
+    "content-type": "application/json; charset=utf-8",
     ...headers,
-  })
-  response.end(JSON.stringify(payload))
-}
+  });
+  response.end(JSON.stringify(payload));
+};
 
 const fail = (response, status, message, headers) =>
-  send(response, { errors: [{ message }] }, status, headers)
+  send(response, { errors: [{ message }] }, status, headers);
 
 const variablesFrom = (url) => {
-  const encoded = url.searchParams.get('variables')
-  if (!encoded) throw new Error('variables are required')
-  const variables = JSON.parse(encoded)
-  if (!isRecord(variables)) throw new Error('variables must be an object')
-  return variables
-}
+  const encoded = url.searchParams.get("variables");
+  if (!encoded) throw new Error("variables are required");
+  const variables = JSON.parse(encoded);
+  if (!isRecord(variables)) throw new Error("variables must be an object");
+  return variables;
+};
 
 const jsonBodyFrom = async (request) => {
-  let body = ''
+  let body = "";
   for await (const chunk of request) {
-    body += chunk
-    if (body.length > 1_000_000) throw new Error('request body is too large')
+    body += chunk;
+    if (body.length > 1_000_000) throw new Error("request body is too large");
   }
-  const parsed = JSON.parse(body)
-  if (!isRecord(parsed)) throw new Error('JSON body must be an object')
-  return parsed
-}
+  const parsed = JSON.parse(body);
+  if (!isRecord(parsed)) throw new Error("JSON body must be an object");
+  return parsed;
+};
 
-const timeline = (entries) => ({ instructions: [{ entries }] })
+const timeline = (entries) => ({ instructions: [{ entries }] });
 
 const server = createServer(async (request, response) => {
-  const url = new URL(request.url ?? '/', `http://127.0.0.1:${port}`)
-  const operation = [
-    'UserByScreenName',
-    'UserTweets',
-    'TweetDetail',
-    'SearchTimeline',
-    'ListsManagementPageTimeline',
-    'ListLatestTweetsTimeline',
-  ].find((name) => url.pathname.endsWith(`/${name}`))
-
-  if (!operation) {
-    fail(response, 501, 'unsupported read operation')
-    return
+  const url = new URL(request.url ?? "/", `http://127.0.0.1:${port}`);
+  if (request.method === "GET" && url.pathname === "/profiles") {
+    send(response, { profiles: ["e2e", "alternate"] });
+    return;
   }
 
-  const expectedMethod = operation === 'SearchTimeline' ? 'POST' : 'GET'
+  const operation = [
+    "UserByScreenName",
+    "UserTweets",
+    "TweetDetail",
+    "SearchTimeline",
+    "ListsManagementPageTimeline",
+    "ListLatestTweetsTimeline",
+  ].find((name) => url.pathname.endsWith(`/${name}`));
+
+  if (!operation) {
+    fail(response, 501, "unsupported read operation");
+    return;
+  }
+
+  const expectedMethod = operation === "SearchTimeline" ? "POST" : "GET";
   if (request.method !== expectedMethod) {
     fail(response, 405, `expected ${expectedMethod}`, {
       allow: expectedMethod,
-    })
-    return
+    });
+    return;
   }
-  if (request.headers['x-profile-name'] !== 'e2e') {
-    fail(response, 403, 'invalid profile')
-    return
+  const profileName = request.headers["x-profile-name"];
+  if (profileName !== "e2e" && profileName !== "alternate") {
+    fail(response, 403, "invalid profile");
+    return;
   }
 
-  let variables
+  let variables;
   try {
-    variables = variablesFrom(url)
+    variables = variablesFrom(url);
   } catch {
-    fail(response, 400, 'malformed variables')
-    return
+    fail(response, 400, "malformed variables");
+    return;
   }
 
-  if (operation === 'UserByScreenName') {
-    if (
-      typeof variables.screen_name !== 'string' ||
-      variables.screen_name.length === 0
-    ) {
-      fail(response, 400, 'screen_name is required')
-      return
+  if (operation === "UserByScreenName") {
+    if (typeof variables.screen_name !== "string" || variables.screen_name.length === 0) {
+      fail(response, 400, "screen_name is required");
+      return;
     }
     send(response, {
       data: {
         user: {
           result: {
-            rest_id: '42',
-            legacy: { screen_name: variables.screen_name, name: 'Yuta' },
+            rest_id: "42",
+            legacy: { screen_name: variables.screen_name, name: "Yuta" },
           },
         },
       },
-    })
-    return
+    });
+    return;
   }
 
-  if (operation === 'UserTweets') {
-    const expectedCursor =
-      variables.cursor === undefined || variables.cursor === 'user-next'
-    if (
-      variables.userId !== '42' ||
-      variables.count !== 20 ||
-      !expectedCursor
-    ) {
-      fail(response, 400, 'invalid user timeline variables')
-      return
+  if (operation === "UserTweets") {
+    const expectedCursor = variables.cursor === undefined || variables.cursor === "user-next";
+    if (variables.userId !== "42" || variables.count !== 20 || !expectedCursor) {
+      fail(response, 400, "invalid user timeline variables");
+      return;
     }
-    const secondPage = variables.cursor === 'user-next'
+    const secondPage = variables.cursor === "user-next";
+    const firstPageText = profileName === "alternate" ? "alternate profile page 1" : "user page 1";
     const entries = secondPage
-      ? [tweet('1010', 'user page 2')]
+      ? [tweet("1010", "user page 2")]
       : [
-          tweet('1001', 'user page 1', 'yuta', {
-            conversationId: '1000',
+          tweet("1001", firstPageText, "yuta", {
+            conversationId: "1000",
           }),
-          cursor('user-next'),
-        ]
+          cursor("user-next"),
+        ];
     send(response, {
       data: {
         user: { result: { timeline: { timeline: timeline(entries) } } },
       },
-    })
-    return
+    });
+    return;
   }
 
-  if (operation === 'ListsManagementPageTimeline') {
+  if (operation === "ListsManagementPageTimeline") {
     if (variables.count !== 100) {
-      fail(response, 400, 'invalid lists management variables')
-      return
+      fail(response, 400, "invalid lists management variables");
+      return;
     }
-    const features = url.searchParams.get('features')
+    const features = url.searchParams.get("features");
     try {
-      if (!features || !isRecord(JSON.parse(features))) throw new Error()
+      if (!features || !isRecord(JSON.parse(features))) throw new Error();
     } catch {
-      fail(response, 400, 'invalid lists management feature lock')
-      return
+      fail(response, 400, "invalid lists management feature lock");
+      return;
     }
     send(response, {
       data: {
@@ -203,25 +200,26 @@ const server = createServer(async (request, response) => {
                     {
                       content: {
                         clientEventInfo: {
-                          component: 'suggest_owned_subscribed_list',
+                          component: "suggest_owned_subscribed_list",
                         },
                         items: [
                           {
                             item: {
                               itemContent: {
                                 list: {
-                                  id_str: '1234567890',
-                                  name: 'My E2E List',
-                                  description: 'Accounts selected for testing',
+                                  id_str: "1234567890",
+                                  name:
+                                    profileName === "alternate" ? "Alternate List" : "My E2E List",
+                                  description: "Accounts selected for testing",
                                   member_count: 10,
-                                  mode: 'Public',
+                                  mode: "Public",
                                   created_at: 1_704_067_200_000,
                                   user_results: {
                                     result: {
-                                      rest_id: '42',
+                                      rest_id: "42",
                                       core: {
-                                        screen_name: 'yuta',
-                                        name: 'Yuta',
+                                        screen_name: "yuta",
+                                        name: "Yuta",
                                       },
                                     },
                                   },
@@ -239,60 +237,65 @@ const server = createServer(async (request, response) => {
           },
         },
       },
-      errors: [{ message: 'optional banner field failed' }],
-    })
-    return
+      errors: [{ message: "optional banner field failed" }],
+    });
+    return;
   }
 
-  if (operation === 'ListLatestTweetsTimeline') {
-    const expectedCursor =
-      variables.cursor === undefined || variables.cursor === 'list-next'
+  if (operation === "ListLatestTweetsTimeline") {
+    const expectedCursor = variables.cursor === undefined || variables.cursor === "list-next";
     if (
-      typeof variables.listId !== 'string' ||
+      typeof variables.listId !== "string" ||
       !/^\d+$/.test(variables.listId) ||
       variables.count !== 20 ||
       !expectedCursor
     ) {
-      fail(response, 400, 'invalid list timeline variables')
-      return
+      fail(response, 400, "invalid list timeline variables");
+      return;
     }
-    const secondPage = variables.cursor === 'list-next'
+    const secondPage = variables.cursor === "list-next";
     const entries = secondPage
-      ? [tweet('3010', 'list page 2', 'listed')]
-      : [tweet('3001', 'list page 1', 'listed'), cursor('list-next')]
+      ? [tweet("3010", "list page 2", "listed")]
+      : [tweet("3001", "list page 1", "listed"), cursor("list-next")];
     send(response, {
       data: {
         list: { tweets_timeline: { timeline: timeline(entries) } },
       },
-    })
-    return
+    });
+    return;
   }
 
-  if (operation === 'TweetDetail') {
-    const focalTweetId = variables.focalTweetId
-    if (typeof focalTweetId !== 'string' || !/^\d+$/.test(focalTweetId)) {
-      fail(response, 400, 'invalid focalTweetId')
-      return
+  if (operation === "TweetDetail") {
+    const focalTweetId = variables.focalTweetId;
+    if (typeof focalTweetId !== "string" || !/^\d+$/.test(focalTweetId)) {
+      fail(response, 400, "invalid focalTweetId");
+      return;
     }
-    const features = url.searchParams.get('features')
-    const fieldToggles = url.searchParams.get('fieldToggles')
+    const features = url.searchParams.get("features");
+    const fieldToggles = url.searchParams.get("fieldToggles");
     try {
-      if (!features || !isRecord(JSON.parse(features))) throw new Error()
+      if (!features || !isRecord(JSON.parse(features))) throw new Error();
       if (!fieldToggles || !isRecord(JSON.parse(fieldToggles))) {
-        throw new Error()
+        throw new Error();
       }
     } catch {
-      fail(response, 400, 'invalid TweetDetail feature locks')
-      return
+      fail(response, 400, "invalid TweetDetail feature locks");
+      return;
     }
 
-    const targetRoot = rootByTarget.get(focalTweetId)
+    const targetRoot = rootByTarget.get(focalTweetId);
     if (targetRoot && variables.cursor === undefined) {
-      const text = focalTweetId === '1001' ? 'user page 1' : 'retry focal'
-      const result = tweetResult(focalTweetId, text, 'focus', {
+      const noReplies = focalTweetId === "3001";
+      const text = noReplies
+        ? "no replies"
+        : focalTweetId === "1001"
+          ? "user page 1"
+          : "retry focal";
+      const result = tweetResult(focalTweetId, text, "focus", {
         conversationId: targetRoot,
         inReplyTo: targetRoot,
-      })
+        replyCount: noReplies ? 0 : 1,
+      });
       send(response, {
         data: {
           tweetResult: { result },
@@ -300,69 +303,77 @@ const server = createServer(async (request, response) => {
             instructions: [
               {
                 entries: [
-                  tweet(focalTweetId, text, 'focus', {
+                  tweet(focalTweetId, text, "focus", {
                     conversationId: targetRoot,
                     inReplyTo: targetRoot,
+                    replyCount: noReplies ? 0 : 1,
                   }),
                 ],
               },
             ],
           },
         },
-      })
-      return
+      });
+      return;
     }
 
-    const targetId = targetByRoot.get(focalTweetId)
+    const targetId = targetByRoot.get(focalTweetId);
     if (!targetId) {
-      fail(response, 400, 'unsupported TweetDetail fixture')
-      return
+      fail(response, 400, "unsupported TweetDetail fixture");
+      return;
     }
-    const expectedCursor = `thread-next:${focalTweetId}`
+    const expectedCursor = `thread-next:${focalTweetId}`;
     if (variables.cursor !== undefined && variables.cursor !== expectedCursor) {
-      fail(response, 400, 'invalid thread cursor')
-      return
+      fail(response, 400, "invalid thread cursor");
+      return;
     }
-    if (
-      variables.cursor &&
-      focalTweetId === '2000' &&
-      !failedThreadRoots.has(focalTweetId)
-    ) {
-      failedThreadRoots.add(focalTweetId)
-      fail(response, 503, 'transient thread fixture failure')
-      return
+    if (variables.cursor && focalTweetId === "3000") {
+      fail(response, 500, "zero-reply thread must not request a continuation");
+      return;
+    }
+    if (variables.cursor && focalTweetId === "2000" && !failedThreadRoots.has(focalTweetId)) {
+      failedThreadRoots.add(focalTweetId);
+      fail(response, 503, "transient thread fixture failure");
+      return;
     }
 
     const entries = variables.cursor
       ? [
-          tweet(`${focalTweetId}3`, 'thread page 2', 'reply2', {
+          tweet(`${focalTweetId}3`, "thread page 2", "reply2", {
             conversationId: focalTweetId,
             inReplyTo: targetId,
           }),
         ]
-      : [
-          tweet(focalTweetId, 'thread root', 'root', {
-            conversationId: focalTweetId,
-          }),
-          tweet(
-            targetId,
-            focalTweetId === '1000' ? 'user page 1' : 'retry focal',
-            'focus',
-            {
+      : focalTweetId === "3000"
+        ? [
+            tweet(focalTweetId, "thread root", "root", {
+              conversationId: focalTweetId,
+            }),
+            tweet(targetId, "no replies", "focus", {
               conversationId: focalTweetId,
               inReplyTo: focalTweetId,
-            },
-          ),
-          tweet(`${focalTweetId}2`, 'thread page 1', 'reply1', {
-            conversationId: focalTweetId,
-            inReplyTo: targetId,
-          }),
-          cursor(expectedCursor),
-        ]
+              replyCount: 0,
+            }),
+            cursor(expectedCursor),
+          ]
+        : [
+            tweet(focalTweetId, "thread root", "root", {
+              conversationId: focalTweetId,
+            }),
+            tweet(targetId, focalTweetId === "1000" ? "user page 1" : "retry focal", "focus", {
+              conversationId: focalTweetId,
+              inReplyTo: focalTweetId,
+            }),
+            tweet(`${focalTweetId}2`, "thread page 1", "reply1", {
+              conversationId: focalTweetId,
+              inReplyTo: targetId,
+            }),
+            cursor(expectedCursor),
+          ];
     send(response, {
       data: {
         tweetResult: {
-          result: tweetResult(focalTweetId, 'thread root', 'root', {
+          result: tweetResult(focalTweetId, "thread root", "root", {
             conversationId: focalTweetId,
           }),
         },
@@ -370,67 +381,62 @@ const server = createServer(async (request, response) => {
           instructions: [{ entries }],
         },
       },
-    })
-    if (variables.cursor && focalTweetId === '2000') {
-      failedThreadRoots.delete(focalTweetId)
+    });
+    if (variables.cursor && focalTweetId === "2000") {
+      failedThreadRoots.delete(focalTweetId);
     }
-    return
+    return;
   }
 
-  const contentType = request.headers['content-type'] ?? ''
+  const contentType = request.headers["content-type"] ?? "";
   if (!/^application\/json(?:\s*;|$)/i.test(contentType)) {
-    fail(response, 400, 'SearchTimeline requires JSON')
-    return
+    fail(response, 400, "SearchTimeline requires JSON");
+    return;
   }
 
-  let body
+  let body;
   try {
-    body = await jsonBodyFrom(request)
+    body = await jsonBodyFrom(request);
   } catch {
-    fail(response, 400, 'malformed JSON body')
-    return
+    fail(response, 400, "malformed JSON body");
+    return;
   }
 
-  const rawQuery = variables.rawQuery
+  const rawQuery = variables.rawQuery;
   const expectedCursor =
-    variables.cursor === undefined ||
-    variables.cursor === `search-next:${rawQuery}`
+    variables.cursor === undefined || variables.cursor === `search-next:${rawQuery}`;
   if (
-    typeof rawQuery !== 'string' ||
+    typeof rawQuery !== "string" ||
     rawQuery.length === 0 ||
     variables.count !== 20 ||
-    variables.querySource !== 'typed_query' ||
-    !['Top', 'Latest'].includes(variables.product) ||
+    variables.querySource !== "typed_query" ||
+    !["Top", "Latest"].includes(variables.product) ||
     !expectedCursor ||
     !isRecord(body.features) ||
-    typeof body.queryId !== 'string' ||
+    typeof body.queryId !== "string" ||
     body.queryId.length === 0 ||
-    Object.hasOwn(body, 'variables')
+    Object.hasOwn(body, "variables")
   ) {
-    fail(response, 400, 'invalid search request')
-    return
+    fail(response, 400, "invalid search request");
+    return;
   }
 
-  const secondPage = variables.cursor !== undefined
-  if (
-    secondPage &&
-    rawQuery.startsWith('retry-') &&
-    !failedRetryQueries.has(rawQuery)
-  ) {
-    failedRetryQueries.add(rawQuery)
-    fail(response, 503, 'transient fixture failure')
-    return
+  const secondPage = variables.cursor !== undefined;
+  if (secondPage && rawQuery.startsWith("retry-") && !failedRetryQueries.has(rawQuery)) {
+    failedRetryQueries.add(rawQuery);
+    fail(response, 503, "transient fixture failure");
+    return;
   }
-  if (secondPage && rawQuery.startsWith('slow-')) {
-    await new Promise((resolve) => setTimeout(resolve, 1_200))
+  if (secondPage && rawQuery.startsWith("slow-")) {
+    await new Promise((resolve) => setTimeout(resolve, 1_200));
   }
 
-  const follows = rawQuery.includes('filter:follows') ? 'follows' : 'all'
-  const label = `${variables.product} · ${follows}`
-  const id = encodeURIComponent(rawQuery)
+  const follows = rawQuery.includes("filter:follows") ? "follows" : "all";
+  const label = `${profileName === "alternate" ? "alternate · " : ""}${variables.product} · ${follows}`;
+  const id = encodeURIComponent(rawQuery);
   const entries = secondPage
     ? [tweet(`s-${id}-2`, `${label} page 2`)]
-    : [tweet(`s-${id}-1`, `${label} page 1`), cursor(`search-next:${rawQuery}`)]
+    : [tweet(`s-${id}-1`, `${label} page 1`), cursor(`search-next:${rawQuery}`)];
 
   send(response, {
     data: {
@@ -438,7 +444,7 @@ const server = createServer(async (request, response) => {
         search_timeline: { timeline: timeline(entries) },
       },
     },
-  })
-})
+  });
+});
 
-server.listen(port, '127.0.0.1')
+server.listen(port, "127.0.0.1");

e2e/models/Base.ts

@@ -1,49 +0,0 @@
-import { expect, type Locator, type Page } from '@playwright/test'
-
-export class Base {
-  readonly ambientLinksLocator: Locator
-  readonly articlesLocator: Locator
-  readonly continuationErrorLocator: Locator
-  readonly endOfFeedLocator: Locator
-  readonly loadingRailLocator: Locator
-  readonly mutationButtonsLocator: Locator
-  readonly mutationLinksLocator: Locator
-
-  constructor(readonly page: Page) {
-    const ambientLinkNames = /ホーム|おすすめ|トレンド|通知|履歴/
-    const mutationControlNames =
-      /投稿する|返信|いいね|再投稿|フォロー|ブックマーク/
-
-    this.ambientLinksLocator = page.getByRole('link', {
-      name: ambientLinkNames,
-    })
-    this.articlesLocator = page.locator('article')
-    this.continuationErrorLocator = page
-      .getByRole('alert')
-      .filter({ hasText: '続きの投稿を取得できませんでした。' })
-    this.endOfFeedLocator = page.getByText('これ以上の投稿はありません。')
-    this.loadingRailLocator = page.locator('.loading-rail')
-    this.mutationButtonsLocator = page.getByRole('button', {
-      name: mutationControlNames,
-    })
-    this.mutationLinksLocator = page.getByRole('link', {
-      name: mutationControlNames,
-    })
-  }
-
-  protected async navigateTo(path: string) {
-    await this.page.goto(path)
-    await this.page.waitForLoadState('networkidle')
-  }
-
-  async tabTo(target: Locator) {
-    await this.page.keyboard.press('Tab')
-    await expect(target).toBeFocused()
-  }
-
-  async retryContinuation() {
-    await this.continuationErrorLocator
-      .getByRole('button', { name: '再試行' })
-      .click()
-  }
-}

e2e/models/HomePage.ts

@@ -1,22 +0,0 @@
-import type { Locator, Page } from '@playwright/test'
-import { Base } from './Base'
-
-export class HomePage extends Base {
-  readonly handleInputLocator: Locator
-  readonly submitButtonLocator: Locator
-
-  constructor(page: Page) {
-    super(page)
-    this.handleInputLocator = page.getByLabel('ハンドルまたはプロフィール URL')
-    this.submitButtonLocator = page.getByRole('button', { name: '表示' })
-  }
-
-  async goTo() {
-    await this.navigateTo('/')
-  }
-
-  async displayUser(handle: string) {
-    await this.handleInputLocator.fill(handle)
-    await this.submitButtonLocator.click()
-  }
-}

e2e/models/ListsPage.ts

@@ -1,11 +0,0 @@
-import { Base } from './Base'
-
-export class ListsPage extends Base {
-  async goTo() {
-    await this.navigateTo('/i/lists')
-  }
-
-  async openList(name: RegExp | string) {
-    await this.page.getByRole('link', { name }).click()
-  }
-}

e2e/models/SearchPage.ts

@@ -1,35 +0,0 @@
-import type { Locator, Page } from '@playwright/test'
-import { Base } from './Base'
-
-export class SearchPage extends Base {
-  readonly followingOnlyLocator: Locator
-  readonly latestRankingLocator: Locator
-  readonly queryInputLocator: Locator
-  readonly searchButtonLocator: Locator
-  readonly topRankingLocator: Locator
-
-  constructor(page: Page) {
-    super(page)
-    this.followingOnlyLocator = page.getByLabel('フォロー中のみ')
-    this.latestRankingLocator = page.getByLabel('最新順')
-    this.queryInputLocator = page.getByLabel('検索語')
-    this.searchButtonLocator = page.getByRole('button', { name: '検索' })
-    this.topRankingLocator = page.getByLabel('人気順')
-  }
-
-  async goTo() {
-    await this.navigateTo('/search?q=&product=Latest&following=false')
-  }
-
-  async search(query: string) {
-    await this.queryInputLocator.fill(query)
-    await this.searchButtonLocator.click()
-  }
-
-  async searchTopFromFollowing(query: string) {
-    await this.queryInputLocator.fill(query)
-    await this.topRankingLocator.check()
-    await this.followingOnlyLocator.check()
-    await this.searchButtonLocator.click()
-  }
-}

e2e/models/ThreadPage.ts

@@ -1,17 +0,0 @@
-import type { Locator, Page } from '@playwright/test'
-import { Base } from './Base'
-
-export class ThreadPage extends Base {
-  readonly headingLocator: Locator
-  readonly selectedPostLabelLocator: Locator
-
-  constructor(page: Page) {
-    super(page)
-    this.headingLocator = page.getByRole('heading', { name: '会話' })
-    this.selectedPostLabelLocator = page.getByText('表示中の投稿')
-  }
-
-  async goTo(handle: string, tweetId: string) {
-    await this.navigateTo(`/${handle}/status/${tweetId}`)
-  }
-}

e2e/models/UserPage.ts

@@ -1,15 +0,0 @@
-import { Base } from './Base'
-
-export class UserPage extends Base {
-  async goTo(handle: string) {
-    await this.navigateTo(`/${handle}`)
-  }
-
-  async openPostDetails(postText: string) {
-    await this.page
-      .getByRole('article')
-      .filter({ hasText: postText })
-      .getByRole('link', { name: '詳細・スレッド' })
-      .click()
-  }
-}

e2e/workspace.ts

@@ -0,0 +1,33 @@
+import { expect, type Page } from "@playwright/test";
+
+export async function showDeckManagement(page: Page) {
+  await expect(page.getByRole("button", { name: "Rename", includeHidden: true })).toBeEnabled();
+  const navigation = page.getByRole("button", {
+    name: "Deck manager",
+    exact: true,
+  });
+  if (!(await navigation.isVisible())) {
+    await page.getByRole("button", { name: "Toggle sidebar" }).click();
+  }
+  await navigation.click();
+}
+
+export async function showResearch(page: Page) {
+  await expect(page.getByRole("button", { name: "Rename", includeHidden: true })).toBeEnabled();
+  const navigation = page.getByRole("button", {
+    name: "Research chat",
+    exact: true,
+  });
+  if (!(await navigation.isVisible())) {
+    await page.getByRole("button", { name: "Toggle sidebar" }).click();
+  }
+  await navigation.click();
+}
+
+export async function closeMobileSidebar(page: Page) {
+  const sheet = page.locator('[data-mobile="true"][data-sidebar="sidebar"]');
+  if (await sheet.isVisible()) {
+    await page.getByRole("button", { name: "Close sidebar", exact: true }).click();
+    await expect(sheet).toBeHidden();
+  }
+}

flake.nix

@@ -22,7 +22,7 @@
             inherit (finalAttrs) pname version src;
             pnpm = pkgs.pnpm_11;
             fetcherVersion = 4;
-            hash = "sha256-XWzEz145/ZJ9rv5vjLiRXlyVXr42URlcouiLVwhRwtE=";
+            hash = "sha256-60nQAoDWoO15P7TFLhABqGNYpJy/R+w+Zz3oo7qD8dM=";
           };
 
           nativeBuildInputs = with pkgs; [
@@ -44,6 +44,10 @@
             cp -r .output/. $out/lib/twitter-lite/
             makeWrapper ${nixpkgs.lib.getExe pkgs.nodejs_22} $out/bin/twitter-lite \
               --add-flags "$out/lib/twitter-lite/server/index.mjs"
+            makeWrapper ${nixpkgs.lib.getExe pkgs.nodejs_22} $out/bin/twitter-lite-backup \
+              --add-flags "$out/lib/twitter-lite/server/tools/backup-database.js"
+            makeWrapper ${nixpkgs.lib.getExe pkgs.nodejs_22} $out/bin/twitter-lite-setup \
+              --add-flags "$out/lib/twitter-lite/server/tools/account-setup.js"
             runHook postInstall
           '';
 
@@ -98,13 +102,13 @@
         let cfg = config.services.twitter-lite;
         in {
           options.services.twitter-lite = {
-            enable = lib.mkEnableOption "Twitter Lite";
+            enable = lib.mkEnableOption "Personal Workspace";
 
             package = lib.mkOption {
               type = lib.types.package;
               default = mkTwitterLite pkgs;
               defaultText = lib.literalExpression "twitter-lite.packages.\${pkgs.system}.default";
-              description = "Twitter Lite package to run.";
+              description = "Personal Workspace package to run.";
             };
 
             relayBaseUrl = lib.mkOption {
@@ -113,40 +117,61 @@
               description = "Base URL of the Twitter relay.";
             };
 
-            profileName = lib.mkOption {
-              type = lib.types.nullOr lib.types.nonEmptyStr;
-              default = null;
-              example = "default";
-              description = "Relay profile to use when the relay has multiple profiles.";
+            publicOrigin = lib.mkOption {
+              type = lib.types.nonEmptyStr;
+              example = "https://home.example-tailnet.ts.net";
+              description = "Exact Tailscale Serve HTTPS origin, without a trailing slash.";
             };
 
-            host = lib.mkOption {
+            allowedLogin = lib.mkOption {
               type = lib.types.nonEmptyStr;
-              default = "127.0.0.1";
-              description = "Address on which Twitter Lite listens.";
+              description = "Tailscale login allowed to access this personal workspace.";
+            };
+
+            credentialKeyFile = lib.mkOption {
+              type = lib.types.nullOr lib.types.str;
+              default = null;
+              example = "/var/lib/secrets/twitter-lite-key";
+              description = "Runtime file containing the base64-encoded 32-byte credential encryption key. Never put this key in the Nix store.";
+            };
+
+            mastodonOrigins = lib.mkOption {
+              type = lib.types.listOf lib.types.nonEmptyStr;
+              default = [ ];
+              example = [ "https://mastodon.social" ];
+              description = "Allowed Mastodon HTTPS origins, without trailing slashes.";
             };
 
             port = lib.mkOption {
               type = lib.types.port;
               default = 3000;
-              description = "Port on which Twitter Lite listens.";
+              description = "Port on which Personal Workspace listens.";
             };
           };
 
           config = lib.mkIf cfg.enable {
             systemd.services.twitter-lite = {
-              description = "Twitter Lite";
+              description = "Personal Workspace";
               after = [ "network.target" ];
               wantedBy = [ "multi-user.target" ];
               environment = {
-                HOST = cfg.host;
+                HOST = "127.0.0.1";
                 PORT = toString cfg.port;
                 TWITTER_RELAY_BASE_URL = cfg.relayBaseUrl;
-              } // lib.optionalAttrs (cfg.profileName != null) {
-                BIRD_PROFILE_NAME = cfg.profileName;
+                TWITTER_LITE_ORIGIN = cfg.publicOrigin;
+                TWITTER_LITE_ALLOWED_LOGIN = cfg.allowedLogin;
+                TWITTER_LITE_DB_PATH = "/var/lib/twitter-lite/workspace.sqlite";
+                TWITTER_LITE_MASTODON_ORIGINS = lib.concatStringsSep "," cfg.mastodonOrigins;
+              } // lib.optionalAttrs (cfg.credentialKeyFile != null) {
+                TWITTER_LITE_CREDENTIAL_KEY_FILE = "%d/credential-key";
               };
               serviceConfig = {
                 DynamicUser = true;
+                StateDirectory = "twitter-lite";
+                StateDirectoryMode = "0700";
+                UMask = "0077";
+                LoadCredential = lib.optional (cfg.credentialKeyFile != null)
+                  "credential-key:${cfg.credentialKeyFile}";
                 ExecStart = lib.getExe cfg.package;
                 Restart = "on-failure";
               };

knip.ts

@@ -1,6 +1,6 @@
-import type { KnipConfig } from 'knip'
+import type { KnipConfig } from "knip";
 
 export default {
-  entry: ['playwright.config.ts', 'e2e/**/*.test.ts', 'e2e/mock-relay.mjs'],
+  entry: ["playwright.config.ts", "e2e/**/*.test.ts", "e2e/mock-relay.mjs"],
   playwright: false,
-} satisfies KnipConfig
+} satisfies KnipConfig;

orval.config.ts

@@ -0,0 +1,72 @@
+import { defineConfig, defineTransformer } from "orval";
+
+const selectedTag = "twitter-lite-e2e";
+const selectedOperationIds = new Set([
+  "getUserByScreenName",
+  "getUserTweets",
+  "getTweetDetail",
+  "getSearchTimeline",
+  "getListLatestTweetsTimeline",
+]);
+
+const selectE2eOperations = defineTransformer((document) => {
+  const foundOperationIds = new Set<string>();
+
+  for (const pathItem of Object.values(document.paths ?? {})) {
+    if (!pathItem || typeof pathItem !== "object") continue;
+
+    for (const candidate of Object.values(pathItem)) {
+      if (
+        !candidate ||
+        typeof candidate !== "object" ||
+        Array.isArray(candidate) ||
+        !("operationId" in candidate)
+      ) {
+        continue;
+      }
+
+      const operation = candidate as {
+        operationId?: string;
+        tags?: string[];
+      };
+
+      if (operation.operationId && selectedOperationIds.has(operation.operationId)) {
+        foundOperationIds.add(operation.operationId);
+        operation.tags = [...(operation.tags ?? []), selectedTag];
+      }
+    }
+  }
+
+  const missingOperationIds = [...selectedOperationIds].filter(
+    (operationId) => !foundOperationIds.has(operationId),
+  );
+  if (missingOperationIds.length > 0) {
+    throw new Error(
+      `twitter-openapi is missing selected operations: ${missingOperationIds.join(", ")}`,
+    );
+  }
+
+  return document;
+});
+
+export default defineConfig({
+  twitterOpenApi: {
+    input: {
+      target:
+        "https://raw.githubusercontent.com/fa0311/twitter-openapi/590dae5c9f8575abc91d3774946bfe6f23960aba/dist/docs/openapi-3.0.yaml",
+      filters: {
+        mode: "include",
+        tags: [selectedTag],
+      },
+      override: {
+        transformer: selectE2eOperations,
+      },
+    },
+    output: {
+      clean: true,
+      client: "fetch",
+      mode: "single",
+      target: "./e2e/generated/twitter-openapi/client.ts",
+    },
+  },
+});

package.json

@@ -2,55 +2,97 @@
   "name": "twitter-lite",
   "private": true,
   "type": "module",
-  "packageManager": "[email protected]",
-  "engines": {
-    "node": ">=22.12.0"
-  },
   "imports": {
     "#/*": "./src/*"
   },
   "scripts": {
+    "db:generate": "drizzle-kit generate && node scripts/bundle-migrations.mjs && oxfmt --write src/features/storage/migrations.generated.ts",
+    "db:backup": "tsx scripts/backup-database.ts",
     "dev": "vite dev --host 127.0.0.1 --port 3000",
-    "dev:tailscale": "vite dev --host 0.0.0.0 --port 3000",
+    "dev:tailscale": "vite dev --host 127.0.0.1 --port 3000",
+    "generate:e2e-openapi": "orval --config orval.config.ts --fail-on-warnings && oxfmt --write e2e/generated",
     "generate-routes": "node scripts/generate-routes.mjs",
     "check:routes": "pnpm generate-routes && git diff --exit-code -- src/routeTree.gen.ts",
-    "build": "vite build",
+    "build": "vite build && node scripts/build-tools.mjs",
     "start": "HOST=127.0.0.1 node .output/server/index.mjs",
     "typecheck": "tsc --noEmit",
-    "lint": "biome check .",
+    "lint": "oxlint",
     "knip": "knip",
-    "format": "biome check --write .",
+    "format": "oxfmt --write .",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:e2e": "playwright test",
-    "test:live": "TWITTER_LITE_LIVE=1 vitest run tests/live/relay.test.ts"
+    "test:live": "TWITTER_LITE_LIVE=1 vitest run tests/live/relay.test.ts",
+    "account:setup": "node --env-file-if-exists=.env.local --import tsx scripts/account-setup.ts",
+    "format:check": "oxfmt --check ."
   },
   "dependencies": {
+    "@base-ui/react": "1.8.0",
+    "@shadcn/react": "^0.3.1",
+    "@tanstack/react-pacer": "^0.23.0",
     "@tanstack/react-query": "5.101.2",
     "@tanstack/react-router": "1.170.17",
     "@tanstack/react-router-ssr-query": "1.167.1",
     "@tanstack/react-start": "1.168.27",
     "@yuta/bird": "0.10.1",
+    "ai": "7.0.118",
+    "ai-sdk-provider-codex-cli": "2.3.0",
+    "better-sqlite3": "13.0.3",
+    "class-variance-authority": "0.7.1",
+    "cn": "^0.4.0",
+    "drizzle-orm": "0.45.3",
+    "lucide-react": "1.48.0",
     "nitro": "3.0.260610-beta",
     "react": "19.2.7",
     "react-dom": "19.2.7",
+    "remark-gfm": "4.0.1",
+    "sanitize-html": "2.17.7",
+    "shadcn": "4.21.0",
+    "streamdown": "^2.6.0",
+    "tw-animate-css": "1.4.0",
+    "usewebmcp": "5.1.0",
     "zod": "4.4.3"
   },
   "devDependencies": {
     "@axe-core/playwright": "4.11.1",
-    "@biomejs/biome": "2.5.3",
     "@playwright/test": "1.61.1",
+    "@shadcn/helpers": "0.2.0",
+    "@shadcn/lint": "^0.2.0",
+    "@tailwindcss/vite": "^4.3.3",
     "@testing-library/dom": "10.4.1",
     "@testing-library/jest-dom": "6.9.1",
     "@testing-library/react": "16.3.2",
+    "@types/better-sqlite3": "9.6.0",
     "@types/node": "26.1.1",
     "@types/react": "19.2.17",
     "@types/react-dom": "19.2.3",
+    "@types/sanitize-html": "2.16.1",
     "@vitejs/plugin-react": "6.0.3",
+    "drizzle-kit": "0.31.11",
     "jsdom": "29.1.1",
     "knip": "6.27.0",
+    "orval": "8.24.0",
+    "oxfmt": "^0.70.0",
+    "oxlint": "^1.85.0",
+    "oxlint-tsgolint": "^7.0.2003",
+    "tailwindcss": "^4.3.3",
+    "tsx": "4.23.12",
     "typescript": "7.0.2",
     "vite": "8.1.4",
     "vitest": "4.1.10"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "packageManager": "[email protected]",
+  "knip": {
+    "ignore": [
+      "e2e/generated/**"
+    ],
+    "ignoreIssues": {
+      "src/components/ui/**": [
+        "exports"
+      ]
+    }
   }
 }

playwright.config.ts

@@ -1,41 +1,49 @@
-import { defineConfig, devices } from '@playwright/test'
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { defineConfig, devices } from "@playwright/test";
 
-const appPort = 4173
-const relayPort = 6911
-const chromiumExecutable = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE
+const appPort = 4173;
+const relayPort = 6911;
+const chromiumExecutable = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE;
+const databasePath =
+  process.env.TWITTER_LITE_E2E_DB_PATH ??
+  join(mkdtempSync(join(tmpdir(), "twitter-lite-e2e-")), "workspace.sqlite");
+process.env.TWITTER_LITE_E2E_DB_PATH = databasePath;
 
 if (!chromiumExecutable) {
   throw new Error(
-    'PLAYWRIGHT_CHROMIUM_EXECUTABLE is required; run E2E tests with `nix develop -c pnpm test:e2e`.',
-  )
+    "PLAYWRIGHT_CHROMIUM_EXECUTABLE is required; run E2E tests with `nix develop -c pnpm test:e2e`.",
+  );
 }
 
 export default defineConfig({
-  testDir: './e2e',
+  testDir: "./e2e",
   fullyParallel: false,
   workers: 1,
   use: {
     baseURL: `http://127.0.0.1:${appPort}`,
+    extraHTTPHeaders: { "Tailscale-User-Login": "[email protected]" },
     launchOptions: { executablePath: chromiumExecutable },
-    screenshot: 'only-on-failure',
-    trace: 'retain-on-failure',
+    screenshot: "only-on-failure",
+    trace: "retain-on-failure",
   },
   webServer: [
     {
-      command: `TWITTER_LITE_MOCK_RELAY_PORT=${relayPort} node e2e/mock-relay.mjs`,
+      command: `TWITTER_LITE_MOCK_RELAY_PORT=${relayPort} pnpm exec tsx e2e/mock-relay.mjs`,
       port: relayPort,
       reuseExistingServer: false,
       timeout: 120_000,
     },
     {
-      command: `TWITTER_RELAY_BASE_URL=http://127.0.0.1:${relayPort} BIRD_PROFILE_NAME=e2e pnpm exec vite dev --host 127.0.0.1 --port ${appPort} --strictPort`,
-      url: `http://127.0.0.1:${appPort}`,
+      command: `WORKSPACE_SETUP_TOKEN=isolated-e2e-setup-token-not-for-production TWITTER_LITE_CODEX_PATH= TWITTER_LITE_REPORT_ROOT= TWITTER_LITE_CODEX_MODEL= TWITTER_LITE_MASTODON_ORIGINS= TWITTER_LITE_CREDENTIAL_KEY_FILE= TWITTER_LITE_DB_PATH=${databasePath} TWITTER_LITE_ORIGIN=http://127.0.0.1:${appPort} [email protected] TWITTER_RELAY_BASE_URL=http://127.0.0.1:${relayPort} BIRD_PROFILE_NAME=e2e pnpm exec vite dev --host 127.0.0.1 --port ${appPort} --strictPort`,
+      port: appPort,
       reuseExistingServer: false,
       timeout: 120_000,
     },
   ],
   projects: [
-    { name: 'desktop', use: { ...devices['Desktop Chrome'] } },
-    { name: 'mobile', use: { ...devices['Pixel 7'] } },
+    { name: "desktop", use: { ...devices["Desktop Chrome"] } },
+    { name: "mobile", use: { ...devices["Pixel 7"] } },
   ],
-})
+});

pnpm-workspace.yaml

@@ -1,2 +1,3 @@
 allowBuilds:
+  better-sqlite3: false
   esbuild: true

scripts/account-setup.ts

@@ -0,0 +1,9 @@
+import { getSetupToken, readAuthState } from "../src/features/auth/auth.server";
+
+if (!readAuthState().needsSetup) {
+  console.error("This workspace already has an owner. Sign in with your existing account.");
+  process.exitCode = 1;
+} else {
+  console.log("Open /setup in your workspace and enter this one-time setup code:");
+  console.log(getSetupToken());
+}

scripts/backup-database.ts

@@ -0,0 +1,11 @@
+import { backupDatabase } from "../src/features/storage/backup.server";
+
+const source = process.env.TWITTER_LITE_DB_PATH;
+const destination = process.argv[2];
+if (!source || !destination || process.argv.length !== 3) {
+  console.error("Usage: TWITTER_LITE_DB_PATH=/absolute/app.db pnpm db:backup /absolute/backup.db");
+  process.exitCode = 1;
+} else {
+  await backupDatabase(source, destination);
+  console.log(`Backup verified: ${destination}`);
+}

scripts/build-tools.mjs

@@ -0,0 +1,13 @@
+import { build } from "vite";
+
+for (const entry of ["backup-database", "account-setup"]) {
+  await build({
+    configFile: false,
+    build: {
+      ssr: `scripts/${entry}.ts`,
+      outDir: ".output/server/tools",
+      emptyOutDir: false,
+      rollupOptions: { external: ["better-sqlite3"] },
+    },
+  });
+}

scripts/bundle-migrations.mjs

@@ -0,0 +1,10 @@
+import { writeFileSync } from "node:fs";
+import { readMigrationFiles } from "drizzle-orm/migrator";
+
+const migrations = readMigrationFiles({
+  migrationsFolder: new URL("../drizzle", import.meta.url).pathname,
+});
+writeFileSync(
+  new URL("../src/features/storage/migrations.generated.ts", import.meta.url),
+  `// Generated by pnpm db:generate. Do not edit.\nexport const migrations = ${JSON.stringify(migrations, null, 2)}\n`,
+);

scripts/generate-routes.mjs

@@ -1,9 +1,9 @@
-import { tanstackStart } from '@tanstack/react-start/plugin/vite'
-import { createServer } from 'vite'
+import { tanstackStart } from "@tanstack/react-start/plugin/vite";
+import { createServer } from "vite";
 
 const server = await createServer({
   configFile: false,
   plugins: [tanstackStart()],
   server: { middlewareMode: true },
-})
-await server.close()
+});
+await server.close();

src/base.css

@@ -0,0 +1,75 @@
+:root {
+  --canvas: var(--color-canvas);
+  --surface: var(--color-paper-2);
+  --paper: var(--color-paper);
+  --ink: var(--color-ink);
+  --accent-hover: var(--color-accent-hover);
+  --control-border: var(--color-control-rule);
+  --error: var(--color-error);
+  color: var(--ink);
+  background: var(--canvas);
+  color-scheme: dark;
+  font-family: var(--font-body);
+  font-size: 14px;
+  font-synthesis: none;
+}
+* {
+  box-sizing: border-box;
+}
+html,
+body {
+  min-width: 320px;
+  overflow-x: clip;
+  background: var(--canvas);
+}
+body {
+  margin: 0;
+}
+button,
+input,
+select {
+  font: inherit;
+}
+a {
+  color: var(--primary);
+  text-underline-offset: 0.18em;
+}
+a:active {
+  color: var(--accent-hover);
+}
+:focus-visible {
+  outline: var(--rule-active) solid var(--color-focus);
+  outline-offset: 2px;
+}
+h1 {
+  margin: 0;
+  min-width: 0;
+  font-family: var(--font-display);
+  font-size: var(--text-display-s);
+  font-weight: 700;
+  line-height: 1.3;
+  overflow-wrap: anywhere;
+}
+.handle {
+  display: block;
+  color: var(--muted-foreground);
+  font-size: var(--text-xs);
+}
+
+.workspace .reader {
+  overflow: hidden;
+}
+.sidebar-note {
+  color: var(--muted-foreground);
+  font-size: var(--text-xs);
+}
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    /* Respect reduced motion over registry component animation utilities. */
+    animation-duration: 0.01ms !important;
+    /* Respect reduced motion over registry component transition utilities. */
+    transition-duration: 0.01ms !important;
+  }
+}

src/components/app-shell.tsx

@@ -1,36 +1,115 @@
-import { Link } from '@tanstack/react-router'
+import { Columns3, MessageSquare, PanelLeftClose } from "lucide-react";
+import { type CSSProperties, type ReactNode, useState } from "react";
+import {
+  Sidebar,
+  SidebarInset,
+  SidebarMenuButton,
+  SidebarMenuItem,
+  SidebarProvider,
+  SidebarTrigger,
+  useSidebar,
+} from "#/components/ui/sidebar";
+import { TooltipProvider } from "#/components/ui/tooltip";
+import { WorkspaceNavigation } from "#/components/workspace-navigation";
 
-export function AppShell({
-  active,
-  children,
-}: {
-  active?: 'user' | 'search' | 'list'
-  children: React.ReactNode
-}) {
+type ShellProps = {
+  hasTemporaryDecks: boolean;
+  sidebar: ReactNode;
+  researchChat: (closeMobileSidebar: () => void) => ReactNode;
+  children: ReactNode;
+};
+
+export function AppShell(props: ShellProps) {
   return (
-    <main className="app">
-      <header className="app-header">
-        <p className="brand">Twitter Lite</p>
-        <nav aria-label="閲覧方法" className="tabs">
-          <Link aria-current={active === 'user' ? 'page' : undefined} to="/">
-            ユーザー
-          </Link>
-          <Link
-            aria-current={active === 'search' ? 'page' : undefined}
-            search={{ q: '', product: 'Latest', following: false }}
-            to="/search"
+    <TooltipProvider delay={800}>
+      <SidebarProvider
+        className="workspace h-dvh min-h-0 overflow-hidden"
+        style={
+          {
+            "--sidebar-width": "25rem",
+            "--sidebar-width-icon": "4rem",
+          } as CSSProperties
+        }
+      >
+        <Workspace {...props} />
+      </SidebarProvider>
+    </TooltipProvider>
+  );
+}
+
+function Workspace({ sidebar, researchChat, children, hasTemporaryDecks }: ShellProps) {
+  const [panel, setPanel] = useState<"chat" | "decks">("chat");
+  const { setOpen, setOpenMobile, isMobile } = useSidebar();
+  const navigation = [
+    { id: "chat", title: "Research chat", icon: MessageSquare },
+    { id: "decks", title: "Deck manager", icon: Columns3 },
+  ] as const;
+
+  return (
+    <>
+      <Sidebar
+        collapsible="icon"
+        className="overflow-hidden transition-none *:data-[sidebar=sidebar]:flex-row"
+      >
+        <WorkspaceNavigation
+          hasTemporaryDecks={hasTemporaryDecks}
+          footer={
+            <SidebarMenuItem>
+              <SidebarMenuButton
+                aria-label="Close sidebar"
+                tooltip={{ children: "Close sidebar", hidden: false }}
+                onClick={() => (isMobile ? setOpenMobile(false) : setOpen(false))}
+                className="size-10 justify-center p-0"
+              >
+                <PanelLeftClose />
+              </SidebarMenuButton>
+            </SidebarMenuItem>
+          }
+        >
+          {navigation.map((item) => (
+            <SidebarMenuItem key={item.id}>
+              <SidebarMenuButton
+                aria-label={item.title}
+                tooltip={{ children: item.title, hidden: false }}
+                isActive={panel === item.id}
+                onClick={() => {
+                  setPanel(item.id);
+                  if (isMobile) setOpenMobile(true);
+                  else setOpen(true);
+                }}
+                className="size-10 justify-center p-0"
+              >
+                <item.icon />
+                <span className="sr-only">{item.title}</span>
+              </SidebarMenuButton>
+            </SidebarMenuItem>
+          ))}
+        </WorkspaceNavigation>
+        <Sidebar collapsible="none" className="min-w-0 flex-1 group-data-[collapsible=icon]:hidden">
+          <div className={panel === "chat" ? "flex min-h-0 flex-1 flex-col" : "hidden"}>
+            {researchChat(() => setOpenMobile(false))}
+          </div>
+          <section
+            aria-label="Deck manager"
+            className={
+              panel === "decks" ? "flex min-h-0 flex-1 flex-col overflow-y-auto p-4" : "hidden"
+            }
           >
-            検索
-          </Link>
-          <Link
-            aria-current={active === 'list' ? 'page' : undefined}
-            to="/i/lists"
-          >
-            リスト
-          </Link>
-        </nav>
-      </header>
-      <section className="reader">{children}</section>
-    </main>
-  )
+            <h2 className="mb-4 text-base font-semibold">Decks</h2>
+            <div className="flex flex-col gap-4">{sidebar}</div>
+          </section>
+        </Sidebar>
+      </Sidebar>
+      <SidebarInset className="min-w-0 overflow-hidden">
+        <header className="flex h-12 shrink-0 items-center gap-2 border-b px-3">
+          <SidebarTrigger aria-label="Toggle sidebar" />
+          <span className="text-sm font-medium">Research</span>
+          <span className="ml-auto text-xs text-muted-foreground">Research workspace</span>
+        </header>
+        <section className="reader flex min-h-0 min-w-0 flex-1 flex-col" aria-label="Decks">
+          {children}
+        </section>
+      </SidebarInset>
+    </>
+  );
 }

src/components/dialog.tsx

@@ -0,0 +1,54 @@
+import { cn } from "cn";
+import { Icon } from "./icon";
+import { Button } from "./ui/button";
+import {
+  DialogClose,
+  DialogContent,
+  DialogHeader,
+  Dialog as DialogRoot,
+  DialogTitle,
+} from "./ui/dialog";
+
+export function Dialog({
+  title,
+  onClose,
+  children,
+  className,
+}: {
+  title: string;
+  className?: string;
+  onClose: () => void;
+  children: React.ReactNode;
+}) {
+  return (
+    <DialogRoot
+      open
+      onOpenChange={(open) => {
+        if (!open) onClose();
+      }}
+    >
+      <DialogContent
+        showCloseButton={false}
+        className={cn("max-h-[calc(100dvh-2rem)] overflow-y-auto", className)}
+        aria-describedby={undefined}
+      >
+        <DialogHeader>
+          <DialogTitle>{title}</DialogTitle>
+        </DialogHeader>
+        <DialogClose
+          render={
+            <Button
+              variant="ghost"
+              size="icon-sm"
+              className="absolute right-2 top-2"
+              aria-label="Close"
+            />
+          }
+        >
+          <Icon name="close" />
+        </DialogClose>
+        {children}
+      </DialogContent>
+    </DialogRoot>
+  );
+}

src/components/icon.tsx

@@ -0,0 +1,32 @@
+const paths = {
+  columns: "M3 4h7v16H3z M14 4h7v16h-7z",
+  hashtag: "M10 3 8 21 M17 3l-2 18 M4 9h16 M3 15h16",
+  search: "M21 21l-5-5 M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0",
+  user: "M20 21v-2a7 7 0 0 0-14 0v2 M17 7a4 4 0 1 1-8 0 4 4 0 0 1 8 0",
+  list: "M8 6h13 M8 12h13 M8 18h13 M3 6h.01 M3 12h.01 M3 18h.01",
+  plus: "M12 5v14 M5 12h14",
+  close: "M6 6l12 12 M18 6 6 18",
+  refresh: "M20 7v5h-5 M4 17v-5h5 M6 6a8 8 0 0 1 14 6 M4 12a8 8 0 0 0 14 6",
+  more: "M5 12h.01 M12 12h.01 M19 12h.01",
+  arrow: "M7 17 17 7 M7 7h10v10",
+  edit: "m16 3 5 5-12 12H4v-5z M14 5l5 5",
+  trash: "M3 6h18 M9 6V3h6v3 M5 6l1 15h12l1-15 M10 10v7 M14 10v7",
+} as const;
+
+export function Icon({ name }: { name: keyof typeof paths }) {
+  return (
+    <svg
+      width="20"
+      height="20"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="1.8"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden="true"
+    >
+      <path d={paths[name]} />
+    </svg>
+  );
+}

src/components/post-text.tsx

@@ -0,0 +1,44 @@
+import type { ReactNode } from "react";
+
+const URL = /(https?:\/\/[^\s]+)/g;
+const HTML_ENTITY = /&(?:#(\d+)|#x([\da-f]+)|amp|apos|gt|lt|quot);/gi;
+const NAMED_ENTITIES: Record<string, string> = {
+  "&amp;": "&",
+  "&apos;": "'",
+  "&gt;": ">",
+  "&lt;": "<",
+  "&quot;": '"',
+};
+function decodeHtmlEntities(text: string): string {
+  return text.replace(HTML_ENTITY, (entity, decimal, hexadecimal) => {
+    if (!decimal && !hexadecimal) {
+      return NAMED_ENTITIES[entity.toLowerCase()] ?? entity;
+    }
+
+    const codePoint = Number.parseInt(decimal ?? hexadecimal, decimal ? 10 : 16);
+    return codePoint <= 0x10ffff ? String.fromCodePoint(codePoint) : entity;
+  });
+}
+
+function linkedText(text: string): ReactNode[] {
+  const decoded = decodeHtmlEntities(text);
+  const parts: ReactNode[] = [];
+  let cursor = 0;
+  for (const match of decoded.matchAll(URL)) {
+    const href = match[0];
+    const start = match.index;
+    if (start > cursor) parts.push(decoded.slice(cursor, start));
+    parts.push(
+      <a href={href} key={`link-${start}`} rel="noreferrer noopener" target="_blank">
+        {href}
+      </a>,
+    );
+    cursor = start + href.length;
+  }
+  if (cursor < decoded.length) parts.push(decoded.slice(cursor));
+  return parts;
+}
+
+export function PostText({ text }: { text: string }) {
+  return <>{linkedText(text)}</>;
+}

src/components/ui/avatar.tsx

@@ -0,0 +1,90 @@
+import { Avatar as AvatarPrimitive } from "@base-ui/react/avatar";
+import { cn } from "cn";
+import type * as React from "react";
+
+function Avatar({
+  className,
+  size = "default",
+  ...props
+}: AvatarPrimitive.Root.Props & {
+  size?: "default" | "sm" | "lg";
+}) {
+  return (
+    <AvatarPrimitive.Root
+      data-slot="avatar"
+      data-size={size}
+      className={cn(
+        "group/avatar relative flex size-8 shrink-0 rounded-full select-none after:absolute after:inset-0 after:rounded-full after:border after:border-border after:mix-blend-darken data-[size=lg]:size-10 data-[size=sm]:size-6 dark:after:mix-blend-lighten",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AvatarImage({ className, ...props }: AvatarPrimitive.Image.Props) {
+  return (
+    <AvatarPrimitive.Image
+      data-slot="avatar-image"
+      className={cn("aspect-square size-full rounded-full object-cover", className)}
+      {...props}
+    />
+  );
+}
+
+function AvatarFallback({ className, ...props }: AvatarPrimitive.Fallback.Props) {
+  return (
+    <AvatarPrimitive.Fallback
+      data-slot="avatar-fallback"
+      className={cn(
+        "flex size-full items-center justify-center rounded-full bg-muted text-sm text-muted-foreground group-data-[size=sm]/avatar:text-xs",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AvatarBadge({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      data-slot="avatar-badge"
+      className={cn(
+        "absolute right-0 bottom-0 z-10 inline-flex items-center justify-center rounded-full bg-primary text-primary-foreground bg-blend-color ring-2 ring-background select-none",
+        "group-data-[size=sm]/avatar:size-2 group-data-[size=sm]/avatar:[&>svg]:hidden",
+        "group-data-[size=default]/avatar:size-2.5 group-data-[size=default]/avatar:[&>svg]:size-2",
+        "group-data-[size=lg]/avatar:size-3 group-data-[size=lg]/avatar:[&>svg]:size-2",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AvatarGroup({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="avatar-group"
+      className={cn(
+        "group/avatar-group flex -space-x-2 *:data-[slot=avatar]:ring-2 *:data-[slot=avatar]:ring-background",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function AvatarGroupCount({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="avatar-group-count"
+      className={cn(
+        "relative flex size-8 shrink-0 items-center justify-center rounded-full bg-muted text-sm text-muted-foreground ring-2 ring-background group-has-data-[size=lg]/avatar-group:size-10 group-has-data-[size=sm]/avatar-group:size-6 [&>svg]:size-4 group-has-data-[size=lg]/avatar-group:[&>svg]:size-5 group-has-data-[size=sm]/avatar-group:[&>svg]:size-3",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Avatar, AvatarBadge, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage };

src/components/ui/badge.tsx

@@ -0,0 +1,48 @@
+import { mergeProps } from "@base-ui/react/merge-props";
+import { useRender } from "@base-ui/react/use-render";
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "cn";
+
+const badgeVariants = cva(
+  "group/badge inline-flex h-5 w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-all focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none [&>svg]:size-3!",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        secondary: "bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80",
+        destructive:
+          "bg-destructive/10 text-destructive focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:focus-visible:ring-destructive/40 [a]:hover:bg-destructive/20",
+        outline: "border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground",
+        ghost: "hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+function Badge({
+  className,
+  variant = "default",
+  render,
+  ...props
+}: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>) {
+  return useRender({
+    defaultTagName: "span",
+    props: mergeProps<"span">(
+      {
+        className: cn(badgeVariants({ variant }), className),
+      },
+      props,
+    ),
+    render,
+    state: {
+      slot: "badge",
+      variant,
+    },
+  });
+}
+
+export { Badge, badgeVariants };

src/components/ui/bubble.tsx

@@ -0,0 +1,123 @@
+import { mergeProps } from "@base-ui/react/merge-props";
+import { useRender } from "@base-ui/react/use-render";
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "cn";
+import type * as React from "react";
+
+function BubbleGroup({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="bubble-group"
+      className={cn("flex min-w-0 flex-col gap-2", className)}
+      {...props}
+    />
+  );
+}
+
+const bubbleVariants = cva(
+  "group/bubble relative flex w-fit max-w-[80%] min-w-0 flex-col gap-1 group-data-[align=end]/message:self-end data-[align=end]:self-end data-[variant=ghost]:max-w-full",
+  {
+    variants: {
+      variant: {
+        default:
+          "*:data-[slot=bubble-content]:bg-primary *:data-[slot=bubble-content]:text-primary-foreground [&>[data-slot=bubble-content]:is(button,a):hover]:bg-primary/80",
+        secondary:
+          "*:data-[slot=bubble-content]:bg-secondary *:data-[slot=bubble-content]:text-secondary-foreground [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[color-mix(in_oklch,var(--secondary),var(--foreground)_5%)]",
+        muted:
+          "*:data-[slot=bubble-content]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[color-mix(in_oklch,var(--muted),var(--foreground)_5%)]",
+        tinted:
+          "*:data-[slot=bubble-content]:bg-[oklch(from_var(--primary)_0.93_calc(c*0.4)_h)] *:data-[slot=bubble-content]:text-foreground dark:*:data-[slot=bubble-content]:bg-[oklch(from_var(--primary)_0.3_calc(c*0.4)_h)] [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[oklch(from_var(--primary)_0.88_calc(c*0.5)_h)] dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-[oklch(from_var(--primary)_0.35_calc(c*0.5)_h)]",
+        outline:
+          "*:data-[slot=bubble-content]:border-border *:data-[slot=bubble-content]:bg-background [&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:text-foreground dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-input/30",
+        ghost:
+          "border-none *:data-[slot=bubble-content]:rounded-none *:data-[slot=bubble-content]:bg-transparent *:data-[slot=bubble-content]:p-0 [&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:text-foreground dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted/50",
+        destructive:
+          "*:data-[slot=bubble-content]:bg-destructive/10 *:data-[slot=bubble-content]:text-destructive dark:*:data-[slot=bubble-content]:bg-destructive/20 [&>[data-slot=bubble-content]:is(button,a):hover]:bg-destructive/20 dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-destructive/30",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+function Bubble({
+  variant = "default",
+  align = "start",
+  className,
+  ...props
+}: React.ComponentProps<"div"> &
+  VariantProps<typeof bubbleVariants> & {
+    align?: "start" | "end";
+  }) {
+  return (
+    <div
+      data-slot="bubble"
+      data-variant={variant}
+      data-align={align}
+      className={cn(bubbleVariants({ variant }), className)}
+      {...props}
+    />
+  );
+}
+
+function BubbleContent({ className, render, ...props }: useRender.ComponentProps<"div">) {
+  return useRender({
+    defaultTagName: "div",
+    props: mergeProps<"div">(
+      {
+        className: cn(
+          "w-fit max-w-full min-w-0 overflow-hidden rounded-xl border border-transparent px-3 py-2 text-sm leading-relaxed wrap-break-word group-data-[align=end]/bubble:self-end [button]:text-left [button,a]:transition-colors [button,a]:outline-none [button,a]:focus-visible:border-ring [button,a]:focus-visible:ring-3 [button,a]:focus-visible:ring-ring/50",
+          className,
+        ),
+      },
+      props,
+    ),
+    render,
+    state: {
+      slot: "bubble-content",
+    },
+  });
+}
+
+const bubbleReactionsVariants = cva(
+  "absolute z-10 flex w-fit shrink-0 items-center justify-center gap-1 rounded-full bg-muted px-1.5 py-0.5 text-sm ring-3 ring-card has-[button]:p-0",
+  {
+    variants: {
+      side: {
+        top: "top-0 -translate-y-3/4",
+        bottom: "bottom-0 translate-y-3/4",
+      },
+      align: {
+        start: "left-3",
+        end: "right-3",
+      },
+    },
+    defaultVariants: {
+      side: "bottom",
+      align: "end",
+    },
+  },
+);
+
+function BubbleReactions({
+  side = "bottom",
+  align = "end",
+  className,
+  ...props
+}: React.ComponentProps<"div"> & {
+  align?: "start" | "end";
+  side?: "top" | "bottom";
+}) {
+  return (
+    <div
+      data-slot="bubble-reactions"
+      data-align={align}
+      data-side={side}
+      className={cn(bubbleReactionsVariants({ side, align }), className)}
+      {...props}
+    />
+  );
+}
+
+export { Bubble, BubbleContent, BubbleGroup, BubbleReactions };

src/components/ui/button.tsx

@@ -0,0 +1,57 @@
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "cn";
+
+const buttonVariants = cva(
+  "group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/80",
+        outline:
+          "border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
+        secondary:
+          "bg-secondary text-secondary-foreground hover:bg-[color-mix(in_oklch,var(--secondary),var(--foreground)_5%)] aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+        ghost:
+          "hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:hover:bg-muted/50",
+        destructive:
+          "bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default:
+          "h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+        lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        icon: "size-8",
+        "icon-xs":
+          "size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm":
+          "size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+        "icon-lg": "size-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  },
+);
+
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  ...props
+}: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>) {
+  return (
+    <ButtonPrimitive
+      data-slot="button"
+      className={cn(buttonVariants({ variant, size, className }))}
+      {...props}
+    />
+  );
+}
+
+export { Button, buttonVariants };

src/components/ui/checkbox.tsx

@@ -0,0 +1,25 @@
+import { Checkbox as CheckboxPrimitive } from "@base-ui/react/checkbox";
+import { cn } from "cn";
+import { CheckIcon } from "lucide-react";
+
+function Checkbox({ className, ...props }: CheckboxPrimitive.Root.Props) {
+  return (
+    <CheckboxPrimitive.Root
+      data-slot="checkbox"
+      className={cn(
+        "peer relative flex size-4 shrink-0 items-center justify-center rounded-[4px] border border-input transition-colors outline-none group-has-disabled/field:opacity-50 group-has-[:focus-visible]/field-label:ring-0 group-has-[:focus-visible]/field-label:not-data-checked:border-input after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 aria-invalid:aria-checked:border-primary dark:bg-input/30 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:border-primary data-checked:bg-primary data-checked:text-primary-foreground group-has-[:focus-visible]/field-label:data-checked:border-primary dark:data-checked:bg-primary",
+        className,
+      )}
+      {...props}
+    >
+      <CheckboxPrimitive.Indicator
+        data-slot="checkbox-indicator"
+        className="grid place-content-center text-current transition-none [&>svg]:size-3.5"
+      >
+        <CheckIcon />
+      </CheckboxPrimitive.Indicator>
+    </CheckboxPrimitive.Root>
+  );
+}
+
+export { Checkbox };

src/components/ui/collapsible.tsx

@@ -0,0 +1,15 @@
+import { Collapsible as CollapsiblePrimitive } from "@base-ui/react/collapsible";
+
+function Collapsible({ ...props }: CollapsiblePrimitive.Root.Props) {
+  return <CollapsiblePrimitive.Root data-slot="collapsible" {...props} />;
+}
+
+function CollapsibleTrigger({ ...props }: CollapsiblePrimitive.Trigger.Props) {
+  return <CollapsiblePrimitive.Trigger data-slot="collapsible-trigger" {...props} />;
+}
+
+function CollapsibleContent({ ...props }: CollapsiblePrimitive.Panel.Props) {
+  return <CollapsiblePrimitive.Panel data-slot="collapsible-content" {...props} />;
+}
+
+export { Collapsible, CollapsibleContent, CollapsibleTrigger };

src/components/ui/dialog.tsx

@@ -0,0 +1,135 @@
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+import { cn } from "cn";
+import { XIcon } from "lucide-react";
+import type * as React from "react";
+import { Button } from "#/components/ui/button.tsx";
+
+function Dialog({ ...props }: DialogPrimitive.Root.Props) {
+  return <DialogPrimitive.Root data-slot="dialog" {...props} />;
+}
+
+function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props) {
+  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
+}
+
+function DialogPortal({ ...props }: DialogPrimitive.Portal.Props) {
+  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
+}
+
+function DialogClose({ ...props }: DialogPrimitive.Close.Props) {
+  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
+}
+
+function DialogOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props) {
+  return (
+    <DialogPrimitive.Backdrop
+      data-slot="dialog-overlay"
+      className={cn(
+        "fixed inset-0 isolate z-50 bg-overlay duration-100 supports-backdrop-filter:backdrop-blur-xs data-open:animate-in data-open:fade-in-0 data-closed:animate-out data-closed:fade-out-0",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function DialogContent({
+  className,
+  children,
+  showCloseButton = true,
+  ...props
+}: DialogPrimitive.Popup.Props & {
+  showCloseButton?: boolean;
+}) {
+  return (
+    <DialogPortal>
+      <DialogOverlay />
+      <DialogPrimitive.Popup
+        data-slot="dialog-content"
+        className={cn(
+          "fixed top-1/2 left-1/2 z-50 grid w-full max-w-[calc(100%-2rem)] -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-popover p-4 text-sm text-popover-foreground ring-1 ring-foreground/10 duration-100 outline-none sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+          className,
+        )}
+        {...props}
+      >
+        {children}
+        {showCloseButton && (
+          <DialogPrimitive.Close
+            data-slot="dialog-close"
+            render={<Button variant="ghost" className="absolute top-2 right-2" size="icon-sm" />}
+          >
+            <XIcon />
+            <span className="sr-only">Close</span>
+          </DialogPrimitive.Close>
+        )}
+      </DialogPrimitive.Popup>
+    </DialogPortal>
+  );
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div data-slot="dialog-header" className={cn("flex flex-col gap-2", className)} {...props} />
+  );
+}
+
+function DialogFooter({
+  className,
+  showCloseButton = false,
+  children,
+  ...props
+}: React.ComponentProps<"div"> & {
+  showCloseButton?: boolean;
+}) {
+  return (
+    <div
+      data-slot="dialog-footer"
+      className={cn(
+        "-mx-4 -mb-4 flex flex-col-reverse gap-2 rounded-b-xl border-t bg-muted/50 p-4 sm:flex-row sm:justify-end",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      {showCloseButton && (
+        <DialogPrimitive.Close render={<Button variant="outline" />}>Close</DialogPrimitive.Close>
+      )}
+    </div>
+  );
+}
+
+function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props) {
+  return (
+    <DialogPrimitive.Title
+      data-slot="dialog-title"
+      className={cn("text-base leading-none font-medium", className)}
+      {...props}
+    />
+  );
+}
+
+function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props) {
+  return (
+    <DialogPrimitive.Description
+      data-slot="dialog-description"
+      className={cn(
+        "text-sm text-muted-foreground *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+};

src/components/ui/dropdown-menu.tsx

@@ -0,0 +1,257 @@
+"use client";
+
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+import { cn } from "cn";
+import { CheckIcon, ChevronRightIcon } from "lucide-react";
+import type * as React from "react";
+
+function DropdownMenu({ ...props }: MenuPrimitive.Root.Props) {
+  return <MenuPrimitive.Root data-slot="dropdown-menu" {...props} />;
+}
+
+function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props) {
+  return <MenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />;
+}
+
+function DropdownMenuTrigger({ ...props }: MenuPrimitive.Trigger.Props) {
+  return <MenuPrimitive.Trigger data-slot="dropdown-menu-trigger" {...props} />;
+}
+
+function DropdownMenuContent({
+  align = "start",
+  alignOffset = 0,
+  side = "bottom",
+  sideOffset = 4,
+  className,
+  ...props
+}: MenuPrimitive.Popup.Props &
+  Pick<MenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">) {
+  return (
+    <MenuPrimitive.Portal>
+      <MenuPrimitive.Positioner
+        className="isolate z-50 outline-none"
+        align={align}
+        alignOffset={alignOffset}
+        side={side}
+        sideOffset={sideOffset}
+      >
+        <MenuPrimitive.Popup
+          data-slot="dropdown-menu-content"
+          className={cn(
+            "z-50 max-h-(--available-height) w-(--anchor-width) min-w-32 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 outline-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:overflow-hidden data-closed:fade-out-0 data-closed:zoom-out-95",
+            className,
+          )}
+          {...props}
+        />
+      </MenuPrimitive.Positioner>
+    </MenuPrimitive.Portal>
+  );
+}
+
+function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props) {
+  return <MenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />;
+}
+
+function DropdownMenuLabel({
+  className,
+  inset,
+  ...props
+}: MenuPrimitive.GroupLabel.Props & {
+  inset?: boolean;
+}) {
+  return (
+    <MenuPrimitive.GroupLabel
+      data-slot="dropdown-menu-label"
+      data-inset={inset}
+      className={cn(
+        "px-1.5 py-1 text-xs font-medium text-muted-foreground data-inset:pl-7",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function DropdownMenuItem({
+  className,
+  inset,
+  variant = "default",
+  ...props
+}: MenuPrimitive.Item.Props & {
+  inset?: boolean;
+  variant?: "default" | "destructive";
+}) {
+  return (
+    <MenuPrimitive.Item
+      data-slot="dropdown-menu-item"
+      data-inset={inset}
+      data-variant={variant}
+      className={cn(
+        "group/dropdown-menu-item relative flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 data-[variant=destructive]:*:[svg]:text-destructive",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props) {
+  return <MenuPrimitive.SubmenuRoot data-slot="dropdown-menu-sub" {...props} />;
+}
+
+function DropdownMenuSubTrigger({
+  className,
+  inset,
+  children,
+  ...props
+}: MenuPrimitive.SubmenuTrigger.Props & {
+  inset?: boolean;
+}) {
+  return (
+    <MenuPrimitive.SubmenuTrigger
+      data-slot="dropdown-menu-sub-trigger"
+      data-inset={inset}
+      className={cn(
+        "flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-popup-open:bg-accent data-popup-open:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <ChevronRightIcon className="ml-auto" />
+    </MenuPrimitive.SubmenuTrigger>
+  );
+}
+
+function DropdownMenuSubContent({
+  align = "start",
+  alignOffset = -3,
+  side = "right",
+  sideOffset = 0,
+  className,
+  ...props
+}: React.ComponentProps<typeof DropdownMenuContent>) {
+  return (
+    <DropdownMenuContent
+      data-slot="dropdown-menu-sub-content"
+      className={cn(
+        "w-auto min-w-[96px] rounded-lg bg-popover p-1 text-popover-foreground shadow-lg ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+        className,
+      )}
+      align={align}
+      alignOffset={alignOffset}
+      side={side}
+      sideOffset={sideOffset}
+      {...props}
+    />
+  );
+}
+
+function DropdownMenuCheckboxItem({
+  className,
+  children,
+  checked,
+  inset,
+  ...props
+}: MenuPrimitive.CheckboxItem.Props & {
+  inset?: boolean;
+}) {
+  return (
+    <MenuPrimitive.CheckboxItem
+      data-slot="dropdown-menu-checkbox-item"
+      data-inset={inset}
+      className={cn(
+        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className,
+      )}
+      checked={checked}
+      {...props}
+    >
+      <span
+        className="pointer-events-none absolute right-2 flex items-center justify-center"
+        data-slot="dropdown-menu-checkbox-item-indicator"
+      >
+        <MenuPrimitive.CheckboxItemIndicator>
+          <CheckIcon />
+        </MenuPrimitive.CheckboxItemIndicator>
+      </span>
+      {children}
+    </MenuPrimitive.CheckboxItem>
+  );
+}
+
+function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props) {
+  return <MenuPrimitive.RadioGroup data-slot="dropdown-menu-radio-group" {...props} />;
+}
+
+function DropdownMenuRadioItem({
+  className,
+  children,
+  inset,
+  ...props
+}: MenuPrimitive.RadioItem.Props & {
+  inset?: boolean;
+}) {
+  return (
+    <MenuPrimitive.RadioItem
+      data-slot="dropdown-menu-radio-item"
+      data-inset={inset}
+      className={cn(
+        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className,
+      )}
+      {...props}
+    >
+      <span
+        className="pointer-events-none absolute right-2 flex items-center justify-center"
+        data-slot="dropdown-menu-radio-item-indicator"
+      >
+        <MenuPrimitive.RadioItemIndicator>
+          <CheckIcon />
+        </MenuPrimitive.RadioItemIndicator>
+      </span>
+      {children}
+    </MenuPrimitive.RadioItem>
+  );
+}
+
+function DropdownMenuSeparator({ className, ...props }: MenuPrimitive.Separator.Props) {
+  return (
+    <MenuPrimitive.Separator
+      data-slot="dropdown-menu-separator"
+      className={cn("-mx-1 my-1 h-px bg-border", className)}
+      {...props}
+    />
+  );
+}
+
+function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      data-slot="dropdown-menu-shortcut"
+      className={cn(
+        "ml-auto text-xs tracking-widest text-muted-foreground group-focus/dropdown-menu-item:text-accent-foreground",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export {
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuGroup,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuPortal,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger,
+};

src/components/ui/empty.tsx

@@ -0,0 +1,93 @@
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "cn";
+
+function Empty({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="empty"
+      className={cn(
+        "flex w-full min-w-0 flex-1 flex-col items-center justify-center gap-4 rounded-xl border-dashed p-6 text-center text-balance",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function EmptyHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="empty-header"
+      className={cn("flex max-w-sm flex-col items-center gap-2", className)}
+      {...props}
+    />
+  );
+}
+
+const emptyMediaVariants = cva(
+  "mb-2 flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-transparent",
+        icon: "flex size-8 shrink-0 items-center justify-center rounded-lg bg-muted text-foreground [&_svg:not([class*='size-'])]:size-4",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+function EmptyMedia({
+  className,
+  variant = "default",
+  ...props
+}: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>) {
+  return (
+    <div
+      data-slot="empty-icon"
+      data-variant={variant}
+      className={cn(emptyMediaVariants({ variant, className }))}
+      {...props}
+    />
+  );
+}
+
+function EmptyTitle({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="empty-title"
+      className={cn("text-sm font-medium tracking-tight", className)}
+      {...props}
+    />
+  );
+}
+
+function EmptyDescription({ className, ...props }: React.ComponentProps<"p">) {
+  return (
+    <div
+      data-slot="empty-description"
+      className={cn(
+        "text-sm/relaxed text-muted-foreground [&>a]:underline [&>a]:underline-offset-4 [&>a:hover]:text-primary",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function EmptyContent({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="empty-content"
+      className={cn(
+        "flex w-full max-w-sm min-w-0 flex-col items-center gap-2.5 text-sm text-balance",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle };

src/components/ui/input-group.tsx

@@ -0,0 +1,145 @@
+"use client";
+
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "cn";
+import type * as React from "react";
+
+import { Button } from "#/components/ui/button.tsx";
+import { Input } from "#/components/ui/input.tsx";
+import { Textarea } from "#/components/ui/textarea.tsx";
+
+function InputGroup({ className, ...props }: React.ComponentProps<"fieldset">) {
+  return (
+    <fieldset
+      data-slot="input-group"
+      className={cn(
+        "group/input-group relative flex h-8 w-full min-w-0 items-center rounded-lg border border-input transition-colors outline-none in-data-[slot=combobox-content]:focus-within:border-inherit in-data-[slot=combobox-content]:focus-within:ring-0 has-disabled:bg-input/50 has-disabled:opacity-50 has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-3 has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot][aria-invalid=true]]:border-destructive has-[[data-slot][aria-invalid=true]]:ring-3 has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>textarea]:h-auto dark:bg-input/30 dark:has-disabled:bg-input/80 dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40 has-[>[data-align=block-end]]:[&>input]:pt-3 has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=inline-end]]:[&>input]:pr-1.5 has-[>[data-align=inline-start]]:[&>input]:pl-1.5",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+const inputGroupAddonVariants = cva(
+  "flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium text-muted-foreground select-none group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      align: {
+        "inline-start": "order-first pl-2 has-[>button]:ml-[-0.3rem] has-[>kbd]:ml-[-0.15rem]",
+        "inline-end": "order-last pr-2 has-[>button]:mr-[-0.3rem] has-[>kbd]:mr-[-0.15rem]",
+        "block-start":
+          "order-first w-full justify-start px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2",
+        "block-end":
+          "order-last w-full justify-start px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2",
+      },
+    },
+    defaultVariants: {
+      align: "inline-start",
+    },
+  },
+);
+
+function InputGroupAddon({
+  className,
+  align = "inline-start",
+  ...props
+}: React.ComponentProps<"fieldset"> & VariantProps<typeof inputGroupAddonVariants>) {
+  return (
+    // oxlint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-noninteractive-element-interactions -- Pointer convenience only; the text control remains independently keyboard-focusable.
+    <fieldset
+      data-slot="input-group-addon"
+      data-align={align}
+      className={cn(inputGroupAddonVariants({ align }), className)}
+      onClick={(e) => {
+        if ((e.target as HTMLElement).closest("button")) {
+          return;
+        }
+        e.currentTarget.parentElement?.querySelector("input")?.focus();
+      }}
+      {...props}
+    />
+  );
+}
+
+const inputGroupButtonVariants = cva("flex items-center gap-2 text-sm shadow-none", {
+  variants: {
+    size: {
+      xs: "h-6 gap-1 rounded-[calc(var(--radius)-3px)] px-1.5 [&>svg:not([class*='size-'])]:size-3.5",
+      sm: "",
+      "icon-xs": "size-6 rounded-[calc(var(--radius)-3px)] p-0 has-[>svg]:p-0",
+      "icon-sm": "size-8 p-0 has-[>svg]:p-0",
+    },
+  },
+  defaultVariants: {
+    size: "xs",
+  },
+});
+
+function InputGroupButton({
+  className,
+  type = "button",
+  variant = "ghost",
+  size = "xs",
+  ...props
+}: Omit<React.ComponentProps<typeof Button>, "size" | "type"> &
+  VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+  }) {
+  return (
+    <Button
+      type={type}
+      data-size={size}
+      variant={variant}
+      className={cn(inputGroupButtonVariants({ size }), className)}
+      {...props}
+    />
+  );
+}
+
+function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      className={cn(
+        "flex items-center gap-2 text-sm text-muted-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function InputGroupInput({ className, ...props }: React.ComponentProps<"input">) {
+  return (
+    <Input
+      data-slot="input-group-control"
+      className={cn(
+        "flex-1 rounded-none border-0 bg-transparent shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">) {
+  return (
+    <Textarea
+      data-slot="input-group-control"
+      className={cn(
+        "flex-1 resize-none rounded-none border-0 bg-transparent py-2 shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export {
+  InputGroup,
+  InputGroupAddon,
+  InputGroupButton,
+  InputGroupInput,
+  InputGroupText,
+  InputGroupTextarea,
+};

src/components/ui/input.tsx

@@ -0,0 +1,19 @@
+import { Input as InputPrimitive } from "@base-ui/react/input";
+import { cn } from "cn";
+import type * as React from "react";
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+  return (
+    <InputPrimitive
+      type={type}
+      data-slot="input"
+      className={cn(
+        "h-8 w-full min-w-0 rounded-lg border border-input bg-transparent px-2.5 py-1 text-base transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Input };

src/components/ui/label.tsx

@@ -0,0 +1,20 @@
+"use client";
+
+import { cn } from "cn";
+import type * as React from "react";
+
+function Label({ className, ...props }: React.ComponentProps<"label">) {
+  return (
+    // oxlint-disable-next-line jsx-a11y/label-has-associated-control -- Association and content are supplied by the caller through props.
+    <label
+      data-slot="label"
+      className={cn(
+        "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Label };