ci: batch Rust and release smoke checks into one job

.agents/skills/rebase-with-upstream/BRAND-AUDIT.md

@@ -0,0 +1,44 @@
+# Brand audit reference
+
+Companion to SKILL.md. What the guard covers, how to classify a hit, and the traps that have bitten past rebases. The guard is `scripts/check-rebrand.ts`; its in-file allowlists and `scripts/rebrand-baseline.json` are the only legitimate exemptions.
+
+## What the guard rejects
+
+Line rules run on every added line (pre-commit: staged; pre-push: pushed ranges; CI: whole tree). Path rules run once per tracked file, so a renamed or binary asset cannot carry a T3 name past a commit.
+
+| Rule id                                                                   | Rejects                                                                                                                                                                                                                                                                                                                                                                                               |
+| ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `t3-connect-copy`                                                         | "T3 Connect" copy anywhere — "T2 Connect" is the brand. Compatibility identifiers (module names like `T3ConnectUserProfilePage`, route ids like `t3-connect`, token types like `t3-link-challenge+jwt`) are not copy; they stay.                                                                                                                                                                      |
+| `t3-copy`                                                                 | "T3 Code"/"T3Code" as first-party copy.                                                                                                                                                                                                                                                                                                                                                               |
+| `t3-wordmark-ref`, `t3-mark-ref`, `t3-wordmark-label`, `t3-wordmark-path` | Retired wordmark/widget-mark components, bare `T3` aria labels, the legacy SVG path fingerprint.                                                                                                                                                                                                                                                                                                      |
+| `t3-cli-scope`                                                            | `@t3code/` — an invented half-rename; the fork CLI is `@t2code/cli` (upstream ships it unscoped as `t3`).                                                                                                                                                                                                                                                                                             |
+| `t3-scope`                                                                | `@t3/` — an invented upstream-adjacent scope; fork packages are `@t2code/*`.                                                                                                                                                                                                                                                                                                                          |
+| `t3tools-scope`, `t3tools-brand`                                          | `@t3tools/` and repository-owned `t3tools` metadata; upstream repo URLs stay.                                                                                                                                                                                                                                                                                                                         |
+| `t3-port`                                                                 | 3773 and derived `3_773`/`13_773` literals; the fork's port is 3772.                                                                                                                                                                                                                                                                                                                                  |
+| `t3-scheme`, `t3-scheme-preview`                                          | `t3code`/`t3code-preview` deep-link schemes outside legacy storage partition names.                                                                                                                                                                                                                                                                                                                   |
+| `t3-env-name`                                                             | `T3CODE_*`/`T3_*` env names. The namespace is `T2CODE_*`/`T2_*`; legacy spellings survive only in the guarded seam files (`packages/shared/src/legacyEnv.ts` + its test), baseline-grandfathered compat lines, and the rule's retained non-env identifiers (`T3_CHAT_THEME`, `T3_CHAT_THEME_ID`, `T3_CODE_*` theme/prompt constants, `T3_PIERRE_ICONS`, `T3_FILE_ICON_SPRITE`, `T3_MCP_TOOL_LABELS`). |
+| `t3-named-path`                                                           | Any tracked path containing `t3` not followed by a digit (avoids `bit31`-style false positives).                                                                                                                                                                                                                                                                                                      |
+| `t3-project-file`                                                         | Restoring upstream's root `t3.json`.                                                                                                                                                                                                                                                                                                                                                                  |
+
+`.agents/`, `.repos/`, and `apps/mobile/modules/` are exempt dirs; the guard's own sources are guarded files. Everything grandfathered is an exact baseline entry — `file` + line for content, `file` + empty line for paths. Remove the entry when you remove the string.
+
+## Classifying a sweep hit
+
+Grep for brand strings across tests and copy-bearing files:
+
+```sh
+rg -n "T3 Code|T3_CODE|@t3code/cli|@t3tools/|t3tools|@t2code/" -g '!node_modules' -g '!.t3' -g '!.repos' -g '!patches/**'
+rg -no "(?<![A-Za-z0-9_])T3(?:CODE)?_[A-Z0-9_]+" -g '!node_modules' -g '!.t3' -g '!.repos' -g '!.agents' -g '!patches/**'
+```
+
+- **Intentional, leave alone:** upstream repo URLs, compatibility-bound platform identifiers (bundle ids like `com.t3tools.t3code`, the AUR `t3code-bin` package name), upstream `@t2code/*` package scope (upstream's CLI is unscoped `t3`; the fork's packages are `@t2code/*` — any `@t2code/` or `@t3code/` outside exempt dirs is a rebase gap), vendored `.repos/`, git blob SHAs inside `patches/`, historical validation notes in comments, mock strings echoed verbatim by both source and test. Existing `t3tools` exceptions must be exact baseline entries; do not add a blanket directory exemption for new hits.
+- **Must be T2:** user-facing copy, error messages, announcements, embedded playbook/prompt text, release names, showcase data — anywhere the source was rebranded but a test fixture or doc still says T3.
+
+## Known traps from past rebases
+
+- **Numeric literals with separators**: `3_773` and `13_773` do not match a `3773` grep. Search `\d_773`, `13_773`, `14_607`-style derived literals separately.
+- **Derived expectations**: tests that compute ports from a base constant shift by one when the base moves; exhaustion-boundary tests (e.g. `startOffset` where `base + offset > 65535`) must be recomputed, not string-replaced.
+- **Embedded copies that must stay byte-identical**: `apps/server/src/cli/triagePrompt.ts` (`TRIAGE_PLAYBOOK`) and `.github/triage/PLAYBOOK.md` must match exactly — rebrand both or neither.
+- **Fixtures as inputs vs expectations**: a `releaseName` a test feeds in and asserts back verbatim can stay as-is only if it is not rebranded upstream; if the real producer (e.g. `resolve-nightly-release.ts`) emits T2, rebrand the fixture too so the test stays realistic.
+- **Env names are contextual, not textual**: legacy `T3CODE_*`/`T3_*` spellings are legitimate in exactly three places — the guarded seam files, baseline-grandfathered compat lines (dual-read fallbacks like `(repoEnv.T2CODE_X ?? repoEnv.T3CODE_X)`, legacy strippers in `infra/relay/scripts/deploy.ts`, boot-service parsers that accept both spellings, workflow `vars.T2_X || vars.T3_X` rotations), and the guard's retained identifier list. Anything else — including prefix checks (`startsWith("T2CODE_")`), sentinel strings (`__T2_SETUP_DONE__`), and generated remote-shell scripts — must use the T2 namespace. Identifier substrings (`LEGACY_T3_CHAT_DARK_THEME_ID`, `devRemoteServerEntryPath`-style camelCase) do not match the rule; do not use that as a loophole to spell env names with a T3 prefix.
+- **Legacy-name coverage lives in dedicated tests**: the fallback path is exercised by `packages/shared/src/legacyEnv.test.ts`, the legacy `T3CODE_HOME` test in `apps/server/src/cli/config.test.ts`, and the legacy env-file fixtures in `scripts/lib/public-config.test.ts`. New env-name tests assert T2 names; do not spread legacy spellings into other fixtures.

.agents/skills/rebase-with-upstream/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: rebase-with-upstream
+description: Rebase the T2 Code fork (ashutoshpw/t2code) onto upstream T3 Code (pingdotgg/t3code) and audit that the T2 Code rebrand still holds after upstream's changes are merged in. Use when rebasing main onto upstream/main, syncing the fork with upstream, or after a rebase when CI fails with "T3" strings the fork had rebranded to "T2".
+---
+
+# Rebase with upstream + rebrand audit
+
+This fork tracks `pingdotgg/t3code` (upstream) and publishes as **T2 Code** on `ashutoshpw/t2code` (origin). A rebase replays the fork's rebrand commits on top of new upstream work, and upstream's new commits routinely contain `T3` strings the rebrand has never seen. The rebase is not done when git says it is; it is done when the brand audit passes.
+
+## Pre-flight
+
+1. Work from a clean tree with local `main` == `origin/main`.
+2. `git fetch origin main && git fetch upstream main`.
+3. Gate on CI before touching history — a rebase rewrites `main`, so starting from a red base makes the post-push loop chase failures the rebase never caused:
+   ```sh
+   gh run list --repo ashutoshpw/t2code --branch main --commit "$(git rev-parse origin/main)"
+   ```
+   - Any run still `queued` or `in_progress`: wait for it to finish before continuing.
+   - Any run concluding `failure` or `cancelled`: abort. Report the failing checks and stop — do not rebase until `origin/main` is green or the user explicitly says go.
+   - No runs for that SHA at all: suspicious rather than green; confirm with the user first.
+4. Review divergence: `git rev-list --left-right --count origin/main...upstream/main`.
+5. Dry-run the conflict surface (Git < 2.38 lacks `merge-tree --write-tree`; use the legacy form):
+   ```sh
+   git merge-tree "$(git merge-base upstream/main origin/main)" upstream/main origin/main
+   ```
+   Count real conflicts with `grep -c '^+<<<'`. Report the plan before rebasing.
+
+## Rebase
+
+1. `git rebase upstream/main`.
+2. Conflict policy — the fork's rebrand wins for user-facing copy, but upstream's structural changes win:
+   - If upstream refactored code the rebrand renamed (extracted variables, moved strings), re-apply the rebrand _inside upstream's new shape_. Example: upstream hoisted an `installArgs` array for an npm fallback path; keep the hoist, keep the `@t2code/cli` package name.
+   - Env vars belong to the T2 namespace (`T2CODE_*`/`T2_*`). Upstream's new env reads and writes must be renamed inside upstream's new shape, and upstream's new tests that assert env names flip with them. External inputs keep working through the legacy-name seam (`@t2code/shared/legacyEnv`, its config helpers in `@t2code/shared/legacyEnvConfig`, and baseline-grandfathered fallback lines) — do not re-widen that seam during a rebase; new upstream variables get T2 names only.
+   - Watch for upstream swapping npm packages (`t3` vs `@t2code/cli`) and URLs (keep upstream repo URLs like `github.com/pingdotgg/t3code` — those are intentional).
+   - Ask the user before adopting any new GitHub Actions entry or edit to an existing one in the fork.
+3. Fold conflict fixes into the fork commit they belong to (`git commit --fixup=<sha>` + `GIT_SEQUENCE_EDITOR=true git rebase -i --autosquash upstream/main`) so history stays at the fork's usual 7-ish commits.
+
+## Rebrand audit (the part that actually catches failures)
+
+The repo ships a brand guard: pre-commit and pre-push hooks run `scripts/check-rebrand.ts` (added staged lines, pushed ranges, and tracked paths) and fail on re-introduced T3 strings — copy, package scopes, ports, schemes, and T3-named file paths alike. Run the same audit over the whole tree before pushing:
+
+```sh
+node scripts/check-rebrand.ts --tree
+```
+
+Hits that are genuinely intentional (legacy compat, upstream references) get exempted via the allowlists in `scripts/check-rebrand.ts` or `scripts/rebrand-baseline.json` (`node scripts/check-rebrand.ts --update-baseline`) — review that diff like code, never `--no-verify`.
+
+Upstream's new tests hardcode `T3` copy that the rebrand commits predate. These failures hide: CI jobs fail fast per package, so later suites never run and each push reveals one more. Do not trust a single green suite — sweep everything.
+
+1. Grep and classify hits per [BRAND-AUDIT.md](./BRAND-AUDIT.md) — the full rule table, the compat-vs-must-rebrand taxonomy, and known traps from past rebases.
+2. The reliable signal is execution, not eyeballing: run every test file that mentions brand copy, plus every test file touched by the rebase. A test that passes is fine regardless of why; a mismatch always shows up as `expected 'T2 …' to equal 'T3 …'` (or the reverse).
+
+## Verify and push
+
+1. Run targeted typecheck for the packages the rebase touched (e.g. `pnpm --filter @t2code/cli run typecheck`).
+2. Update `origin/main` with `git push --force-with-lease origin main` — a rebase always rewrites the fork's main.
+3. Poll CI on the pushed head. When a job fails, check whether it is a new rebrand gap (fix, fixup into the right commit, push) or a masked suite that now runs for the first time (expect a few rounds on busy rebases). Stop when every check is green on the latest commit.
+
+## Report what changed
+
+A finished rebase is not just a green push — close every run with a short summary the user can scan. Keep it to bullets, one line each; cite `file:line` when pointing at a specific decision.
+
+1. **The rebase**: upstream range (old tip → new tip), how many upstream commits were picked up, how many fork commits replayed, and the pushed head SHA.
+2. **Conflict work**: the resolutions that mattered, not every file — structural calls (whose side won and why), rebrands re-applied inside upstream's new shape, and any fork commit that became obsolete, was dropped, or was folded away.
+3. **Rebrand gaps found**: what the audit caught and fixed, plus keeper classifications worth remembering (things that look like gaps but are intentional).
+4. **Verification**: what actually ran — guard, typechecks, test suites — and their results. Note anything that could not be verified locally and is only covered by CI.
+5. **Flags for the user**: pre-existing failures, deliberate deviations from upstream, removed legacy seams, and anything that needs a decision (e.g. a URL a rename would 404).
+
+If a round was aborted, or CI is not green on the latest commit, say so explicitly instead of implying success.

.agents/skills/test-t3-mobile/SKILL.md → .agents/skills/test-t2-mobile/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: test-t3-mobile
-description: Test T3 Code's native iOS and Android app through its Device panel and returned AgentDevice command. Use for mobile verification, native-client builds, Metro launch, and mobile pairing against isolated development state.
+name: test-t2-mobile
+description: Test T2 Code's native iOS and Android app through its Device panel and returned AgentDevice command. Use for mobile verification, native-client builds, Metro launch, and mobile pairing against isolated development state.
 ---
 
-# Test T3 Mobile
+# Test T2 Mobile
 
 ## Open the device
 
@@ -26,7 +26,7 @@ Test with meaningful project and thread data. Read the shared
 [SQLite fixture reference](../test-t3-app/references/sqlite-fixtures.md) only
 when inspecting or seeding SQLite. Stop the test server before fixture writes.
 
-## Launch T3 Code Dev
+## Launch T2 Code Dev
 
 From the checkout being tested on the selected device host, run:
 
@@ -39,7 +39,7 @@ mobile verification includes that build step unless the user prohibits it.
 
 Start `vp run dev:client` from `apps/mobile`, or reuse a healthy Metro belonging
 to this checkout. Open its printed development-client URL with AgentDevice
-`open com.t3tools.t3code.dev <url>` and all returned target arguments.
+`open codes.t2.desktop.dev <url>` and all returned target arguments.
 The device must be able to reach both Metro and the isolated backend.
 
 ## Pair and verify
@@ -49,12 +49,12 @@ arguments stored in `agent_device_command` and the Bash array
 `agent_device_target_args`:
 
 ```bash
-.agents/skills/test-t3-mobile/scripts/pair-client.sh \
+.agents/skills/test-t2-mobile/scripts/pair-client.sh \
   <server-port> <base-dir> <device-reachable-backend-origin> \
   "$agent_device_command" "${agent_device_target_args[@]}"
 ```
 
-It issues a fresh credential and opens T3 Code Dev's existing pairing route
+It issues a fresh credential and opens T2 Code Dev's existing pairing route
 through AgentDevice. For a backend on the device host, use
 `http://127.0.0.1:<server-port>` on iOS or `http://10.0.2.2:<server-port>`
 on Android. For a remote backend, use its reachable origin.

.agents/skills/test-t2-mobile/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Test T2 Mobile"
+  short_description: "Test T2 Code on iOS or Android"
+  default_prompt: "Use $test-t2-mobile to launch T2 Code against an isolated backend and verify the affected flow on an available simulator or emulator."

.agents/skills/test-t3-mobile/scripts/pair-client.sh → .agents/skills/test-t2-mobile/scripts/pair-client.sh

@@ -9,11 +9,31 @@ usage() {
 
 [[ $# -ge 5 ]] || usage
 
+<<<<<<< HEAD
 server_port="$1"
 base_dir="$2"
 mobile_origin="$3"
 agent_device_command="$4"
 shift 4
+=======
+platform="$1"
+device_id="$2"
+server_port="$3"
+base_dir="$4"
+url_scheme="${5:-t2code-dev}"
+
+case "$platform" in
+  ios)
+    mobile_origin="http://127.0.0.1:${server_port}"
+    ;;
+  android)
+    mobile_origin="http://10.0.2.2:${server_port}"
+    ;;
+  *)
+    usage
+    ;;
+esac
+>>>>>>> 7b901800f (rebrand: move remaining @t3tools packages to the @t2code namespace)
 
 repo_root="$(git rev-parse --show-toplevel)"
 cd "$repo_root"
@@ -44,7 +64,7 @@ process.stdout.write(`t3code-dev://connections/new?${query}`);
 NODE
 )"
 
-if ! "$agent_device_command" open com.t3tools.t3code.dev "$deep_link" "$@" \
+if ! "$agent_device_command" open codes.t2.mobile.dev "$deep_link" "$@" \
   >/dev/null 2>&1; then
   echo "AgentDevice could not open the pairing route. Check the Device panel and retry with a fresh credential." >&2
   exit 1