sync upstream main

.agents/skills/test-t3-app/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: test-t3-app
+description: Launch and test the T3 Code web app in isolated development environments, including first-try browser authentication with one-time pairing URLs, pairing-token recovery, worktree-safe state directories, dev server lifecycle, and direct SQLite inspection or fixture seeding. Use when an agent needs to run T3 locally, test UI behavior in a browser, recover from an expired or consumed pairing token, isolate dev state, or prepare test data in state.sqlite.
+---
+
+# Test T3 App
+
+## Start an isolated web environment
+
+1. Run commands from the repository root.
+2. Choose a base directory that belongs only to the current worktree or test:
+   - Use the repository's ignored `.t3` directory for reusable worktree-local state.
+   - Use `mktemp -d /tmp/t3code-test.XXXXXX` for disposable state and retain the printed absolute path.
+3. Start the full web stack with `vp run dev --home-dir <base-dir>`.
+4. Keep the terminal session alive and read the selected server port, web port, base directory, and pairing URL from its output.
+
+Treat a base directory as disposable only when it was created or deliberately selected for the current test. Never delete or directly seed the shared `~/.t3` directory. Prefer starting with a new temporary base directory over clearing state of uncertain ownership.
+
+The dev runner disables browser auto-open by default. Do not pass `--browser` during automated testing: an automatically opened page can consume the one-time bootstrap token before the controlled browser uses it.
+
+## Authenticate the browser on the first navigation
+
+1. Wait for the server log that says authentication is required and includes a URL ending in `/pair#token=...`.
+2. Use the controlled in-app browser or browser-automation surface available to the agent. Do not use a system-browser launch command during automated testing.
+3. Open that complete URL exactly once as the controlled browser's first navigation. Preserve the fragment and token verbatim.
+4. Wait for the pairing exchange and redirect to finish before navigating elsewhere.
+5. Continue in the same browser context so its stored bearer session remains available.
+
+Treat pairing URLs as secrets. Do not copy them into final responses, screenshots, committed files, or durable logs. A pairing token is short-lived and single-use; opening the URL in another browser or opening it twice can consume it.
+
+## Recover a consumed or expired pairing token
+
+Create another token against the same database and web URL as the running dev server:
+
+```bash
+T3CODE_PORT=<server-port> node apps/server/src/bin.ts auth pairing create \
+  --base-dir <base-dir> \
+  --dev-url <web-url> \
+  --base-url <web-url> \
+  --ttl 15m \
+  --label agent-ui-test
+```
+
+Use the `Pair URL` from this command once. Derive `<server-port>` and `<web-url>` from the current dev-runner output, including any automatically selected port offset. Setting `T3CODE_PORT` keeps the administrative CLI from probing for an unrelated free port.
+
+Always pass `--dev-url` for a dev-runner environment so the generated pairing URL uses the current web origin. An explicit base directory stores runtime state in `<base-dir>/userdata`; the `<base-dir>/dev` fallback is only used by an implicit dev home. Use `auth pairing list` to inspect active token metadata; it intentionally cannot reveal token secrets.
+
+## Inspect or seed SQLite state
+
+Read [references/sqlite-fixtures.md](references/sqlite-fixtures.md) before changing the database.
+
+- Use `node apps/server/scripts/t3-sqlite-state.ts query` for schema discovery and read-only checks.
+- Stop the dev server before using `node apps/server/scripts/t3-sqlite-state.ts exec`, then restart it with the same base directory.
+- Seed projection tables only for disposable UI fixtures. Use application commands and APIs when testing business behavior or projection correctness.
+- Use the auth CLI, not direct `auth_*` table edits, for pairing and sessions.
+
+The helper refuses to write to the shared `~/.t3` directory by default and creates a database backup before each mutation.
+
+## Finish the test
+
+Stop the dev process with its terminal interrupt. Preserve the isolated base directory when it contains useful reproduction evidence; otherwise remove only a path that was created for this test after resolving and verifying the exact target. A fresh isolated base directory is the safest reset when authentication, migrations, or fixture state becomes ambiguous.
+
+## Troubleshoot predictably
+
+- If the browser shows an unauthenticated pairing screen, issue a new token instead of retrying the consumed URL.
+- If the pairing URL is no longer visible, create a replacement token with both `--dev-url` and `--base-url`.
+- If the replacement token is rejected, verify that the CLI and server use the identical absolute base directory and web URL.
+- If the UI shows unexpected data, verify that every command uses the identical explicit base directory before editing anything.
+- If ports move because another instance is running, trust the current dev-runner output rather than assuming ports `13773` and `5733`.

.agents/skills/test-t3-app/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "T3 App Testing"
+  short_description: "Launch and seed isolated T3 test environments"
+  default_prompt: "Use $test-t3-app to launch an isolated T3 development environment and test it in the browser."

.agents/skills/test-t3-app/references/sqlite-fixtures.md

@@ -0,0 +1,58 @@
+# SQLite fixtures
+
+Load this reference only when inspecting or seeding local T3 state directly.
+
+## Select the correct database
+
+When `--base-dir` or `--home-dir` is explicit, runtime state lives under `<base-dir>/userdata` and the database path is `<base-dir>/userdata/state.sqlite`. The `<base-dir>/dev` state directory is only the fallback for an implicit development home, preventing an ordinary `vp run dev` from touching production state.
+
+Start the target runtime once before seeding so all migrations have run. Use an isolated base directory. Stop the server before writes to avoid racing application state or an active projection.
+
+## Use the helper
+
+List tables:
+
+```bash
+node apps/server/scripts/t3-sqlite-state.ts query \
+  --base-dir <base-dir> \
+  --sql "SELECT name FROM sqlite_schema WHERE type = 'table' ORDER BY name"
+```
+
+Inspect current columns before writing a fixture:
+
+```bash
+node apps/server/scripts/t3-sqlite-state.ts query \
+  --base-dir <base-dir> \
+  --sql "PRAGMA table_info(projection_threads)"
+```
+
+Apply a SQL fixture from a file:
+
+```bash
+node apps/server/scripts/t3-sqlite-state.ts exec \
+  --base-dir <base-dir> \
+  --file /tmp/t3-seed.sql
+```
+
+Use one statement per invocation for both `query` and `exec`; the helper wraps writes in a transaction and prints the backup path after a successful mutation. Use a single insert with multiple value rows when a fixture needs several records.
+
+## Seed projection data carefully
+
+The web UI primarily reads these projection tables:
+
+- `projection_projects`
+- `projection_threads`
+- `projection_thread_messages`
+- `projection_thread_activities`
+- `projection_thread_sessions`
+- `projection_turns`
+- `projection_pending_approvals`
+- `projection_thread_proposed_plans`
+
+Inspect `PRAGMA table_info(<table>)` and the current migrations under `apps/server/src/persistence/Migrations/` before constructing inserts. Keep identifiers unique, timestamps as ISO strings, JSON columns valid, and related project/thread/turn IDs consistent.
+
+For a substantial current example, inspect `seedDatabase` in `scripts/mobile-showcase-environment.ts`. Adapt its column set to the target database instead of assuming copied SQL remains current.
+
+Direct projection writes are appropriate for ephemeral visual states, edge-case counts, long titles, activity lists, and similar UI fixtures. They do not create a coherent orchestration event history. Do not modify `orchestration_events` unless the test specifically exercises projector internals, and do not use direct projection writes to claim backend business behavior works.
+
+Use the app's commands or APIs for behavior tests. Use `node apps/server/src/bin.ts auth ...` for auth state rather than editing `auth_pairing_links` or `auth_sessions`.

.claude/skills

@@ -0,0 +1 @@
+../.agents/skills

.env.example

@@ -18,6 +18,10 @@
 # Get this from your relay deployment. `infra/relay` deploys update it automatically.
 # T3CODE_RELAY_URL=https://relay.example.com
 
+# Optional: hosted app origin used by the CLI's out-of-band OAuth flow.
+# Defaults to https://app.t3.codes; override to test against a staging deployment.
+# T3CODE_HOSTED_APP_URL=https://nightly.app.t3.codes
+
 # Public, ingest-only mobile OpenTelemetry configuration.
 # T3CODE_MOBILE_OTLP_TRACES_URL=https://api.axiom.co/v1/traces
 # T3CODE_MOBILE_OTLP_TRACES_DATASET=t3-code-mobile-traces-dev