@terreno/mcp 0.29.0 → 0.31.0

package/src/docs/versioned/0.30.0/tasks/upgrade-guides-and-skill.md

@@ -0,0 +1,118 @@
+# Task List: Upgrade Guides and the `upgrading-terreno` Skill
+
+See: [`docs/implementationPlans/upgrade-guides-and-skill.md`](../implementationPlans/upgrade-guides-and-skill.md)
+
+**RTK deprecation flag:** **Blocked.** The RTK → syncdb upgrade is the primary use case for this skill. Do not start until PR #869 merges and [`rtk-to-syncdb-migration-docs`](rtk-to-syncdb-migration-docs.md) Phase 3 has produced the migration guide the skill will delegate to. Tasks marked `[RTK]` specifically handle that migration.
+
+## Instructions for the implementing agent
+
+- Derive upgrade-note content from evidence: `gh release view <tag>`, `git log <prev>..<tag>`, and diffs of public API surfaces (`*/src/index.ts`). Do not write "possibly breaking" — determine whether it breaks by reading the diff.
+- Read `.rulesync/skills/upgrading-expo/SKILL.md` before writing the new skill. Do not duplicate its content; invoke it.
+- The skill must never leave a consumer's repo in a half-upgraded state without saying so. Every failure path must report what succeeded, what failed, and how to roll back.
+- Run `bun run mcp:build` after changing anything under `mcp-server/`. Run `bun run rules:check` after touching `.rulesync/`.
+
+## Phase 1: Note format and backfill
+
+- [ ] **Task 1.1**: Define the upgrade note format
+  - Description: Create `mcp-server/src/docs/upgrades/README.md` documenting the required note format from the IP: frontmatter-style header (`Action required`, `Affected packages`) then `Summary`, `Breaking changes` (each with What changed / Why / Migration with before-and-after code), `Deprecations`, `New capabilities`, `Verification`. Explain that notes are concatenated by `terreno_get_upgrade_guide` across a version range, so each must be self-contained and must not assume the reader read an adjacent note. Include a copy-paste template. Read the existing `0.20.0.md` and `0.21.0.md` first and keep the format compatible with them.
+  - Files: `mcp-server/src/docs/upgrades/README.md` (new)
+  - Depends on: none
+  - Acceptance: the format is compatible with the two existing notes; the template includes every required section; the self-contained requirement is stated with its reason.
+
+- [ ] **Task 1.2**: Research what changed between 0.21.0 and the current version
+  - Description: For each release from 0.22.0 through the current version, run `gh release view <tag>` and `git log --oneline <prev>..<tag>`, and diff the public surface of each published package (`git diff <prev>..<tag> -- '*/src/index.ts'`). Identify actual breaking changes, deprecations, and notable additions. Record findings per version in the PR body. Pay particular attention to the OpenFeature feature-flag migration, which the README documents as requiring consumer action — that is a breaking change with no upgrade note.
+  - Files: none (findings in the PR body)
+  - Depends on: Task 1.1
+  - Acceptance: every version from 0.22.0 to current is covered; each finding cites a commit or diff; the feature-flag migration is captured.
+
+- [ ] **Task 1.3**: Write the consolidated backfill note
+  - Description: Per IP question U1, write a single consolidated note covering 0.21.0 → current (name it for the current version). Include everything from Task 1.2 that requires consumer action, organized by concern rather than by version. Open with an honest note that per-release notes were not maintained for this range and that this note consolidates them. Move the OpenFeature feature-flag migration content out of `README.md` into this note (or into `docs/how-to/add-feature-flags.md`) and link it, rather than leaving a migration guide in the README.
+  - Files: `mcp-server/src/docs/upgrades/<current-version>.md` (new), `README.md`, `docs/how-to/add-feature-flags.md`
+  - Depends on: Task 1.2
+  - Acceptance: every action-requiring change from Task 1.2 appears; the feature-flag migration is no longer in `README.md`; `terreno_get_upgrade_guide` with the range 0.21.0 → current returns this note's content.
+
+- [ ] **Task 1.4**: Improve the empty-range response
+  - Description: Update `terreno_get_upgrade_guide` in `mcp-server/src/tools.ts` so that a range with no recorded notes returns an explicit message naming the versions with no notes, rather than empty output — an agent seeing empty output concludes nothing changed, which is the opposite of the truth. Also have it list which versions in the range *did* have notes. Add tests for: range fully covered, range partially covered, range with no notes, and an invalid range.
+  - Files: `mcp-server/src/tools.ts`, tests under `mcp-server/src/`
+  - Depends on: Task 1.3
+  - Acceptance: all four test cases pass; the no-notes response names the specific versions; `bun run mcp:build` succeeds.
+
+## Phase 2: Versioning policy
+
+- [ ] **Task 2.1**: Write `docs/explanation/versioning-policy.md`
+  - Description: Document: what lockstep versioning means (all `@terreno/*` packages share a version; you upgrade them together and mixing versions is unsupported — verify this claim against `publish-on-tag.yml` and any peer-dependency constraints before asserting it); the pre-1.0 policy (breaking changes may land in minor releases, always with an upgrade note); the deprecation window from IP question U6 (minimum three minor releases, with the RTK deprecation as the worked example); where to find upgrade notes and the changelog; and what 1.0 will mean when it happens (link program question P9). Keep it short and concrete — this document is a promise, so every sentence must be one the team will keep.
+  - Files: `docs/explanation/versioning-policy.md` (new), `docs/explanation/README.md`
+  - Depends on: Task 1.3
+  - Acceptance: the lockstep claim is verified against the publish workflow and peer deps; the deprecation window is a specific number; the RTK deprecation is used as the example; linked from the explanation index.
+
+- [ ] **Task 2.2**: `[RTK]` Write `docs/how-to/upgrade-terreno.md`
+  - Description: The human-facing upgrade guide. Cover: checking your current versions; finding the notes for your range (both via `terreno_get_upgrade_guide` and by browsing the notes directory); the correct ordering with the reasoning for each step (backend before frontend because the OpenAPI spec is the contract; Expo before Terreno frontend packages because `@terreno/ui` pins peers against Expo versions — verify both claims); the manual steps for each phase; verification; and rollback. Add a prominent section for the RTK → syncdb upgrade linking `docs/how-to/migrate-rtk-to-syncdb.md` as a larger, separate operation that should not be combined with a routine version bump.
+  - Files: `docs/how-to/upgrade-terreno.md` (new), `docs/how-to/README.md`
+  - Depends on: Task 2.1
+  - Acceptance: both ordering claims verified against source or `package.json` peer deps and cited; the RTK migration is explicitly separated from routine upgrades; rollback steps present.
+
+## Phase 3: The skill
+
+- [ ] **Task 3.1**: Author the `upgrading-terreno` skill
+  - Description: Create `.rulesync/skills/upgrading-terreno/SKILL.md`. Frontmatter: `name: upgrading-terreno`, a `description` naming trigger phrases ("upgrade Terreno", "bump @terreno packages", "update to the latest Terreno", "upgrade terreno version"), `targets: ['*']`. Body: Preconditions (clean git tree — refuse to start otherwise; on a branch, not the default branch; tests currently passing so failures are attributable); Determine versions (`application_info` from the local MCP server, or read `package.json` files); Fetch notes (`terreno_get_upgrade_guide`); **Plan and confirm** — print current version, target version, the notes found, the packages affected, and the ordered steps, then stop for confirmation; then the ten-step ordering from the IP with a verification gate between each phase; Expo delegation (invoke the `upgrading-expo` skill at step 6 rather than duplicating it); Failure handling (report what succeeded, what failed, and the rollback command; on a multi-version jump failure, retry version by version to isolate); and a final report. Include an explicit prohibition on continuing past a failed compile or test run.
+  - Files: `.rulesync/skills/upgrading-terreno/SKILL.md` (new)
+  - Depends on: Task 2.2
+  - Acceptance: the clean-tree precondition is a hard refusal, not a warning; the confirmation gate precedes the first mutation; step 6 invokes `upgrading-expo` by name; the failure path names a rollback command; the ordering matches the how-to guide exactly.
+
+- [ ] **Task 3.2**: Add the ordering reference
+  - Description: Create `.rulesync/skills/upgrading-terreno/references/ordering.md` containing the dependency reasoning in detail: why backend precedes frontend, why the typed client is regenerated only after the backend is upgraded and running, why Expo precedes `@terreno/ui`, which packages are backend versus frontend (enumerate them from `publish-on-tag.yml`), and what breaks if the order is violated — with the specific symptom for each violation (for example: regenerating the client against an old backend produces a client missing the new routes, which fails at compile time in the consumer's screens).
+  - Files: `.rulesync/skills/upgrading-terreno/references/ordering.md` (new)
+  - Depends on: Task 3.1
+  - Acceptance: every package is classified backend or frontend and the list matches `publish-on-tag.yml`; each ordering rule has a concrete violation symptom.
+
+- [ ] **Task 3.3**: `[RTK]` Add the syncdb migration branch
+  - Description: Add a section to the skill for the case where the upgrade range crosses the syncdb release. The skill must detect this (the range includes the syncdb version), stop, and tell the user that this is a platform migration rather than a version bump, pointing at `docs/how-to/migrate-rtk-to-syncdb.md` and offering to perform the routine version bump first and the migration as a separate operation. Do not attempt to automate the full migration inside a version-bump flow.
+  - Files: `.rulesync/skills/upgrading-terreno/SKILL.md`
+  - Depends on: Task 3.1, `rtk-to-syncdb-migration-docs` Phase 3
+  - Acceptance: the skill detects a range crossing the syncdb version and stops with the two-option choice; it does not attempt the data-layer migration automatically.
+
+- [ ] **Task 3.4**: Wire the MCP prompt to the skill
+  - Description: Update the `terreno_upgrade` prompt in `mcp-server/src/prompts.ts` so it points at the `upgrading-terreno` skill as the executor, keeping the prompt as the discovery surface for agents without skill support. Ensure the prompt's ordering matches the skill's exactly so the two cannot drift into disagreement — ideally the prompt references the ordering rather than restating it.
+  - Files: `mcp-server/src/prompts.ts`
+  - Depends on: Task 3.1
+  - Acceptance: the prompt names the skill; the two do not state conflicting orderings; `bun run mcp:build` succeeds.
+
+- [ ] **Task 3.5**: Generate skill mirrors
+  - Description: Run `bun run rules` and commit all generated files.
+  - Files: generated skill mirrors
+  - Depends on: Task 3.1, Task 3.2, Task 3.3
+  - Acceptance: `bun run rules:check` exits 0; `upgrading-terreno` appears under every configured target directory.
+
+## Phase 4: Enforcement
+
+- [ ] **Task 4.1**: Require upgrade notes in the release skill
+  - Description: Add a required step to `.rulesync/skills/release/SKILL.md`: after assembling the changelog section for the release, if it contains a `Breaking`, `Deprecated`, `Removed`, or `Changed` entry, write `mcp-server/src/docs/upgrades/<version>.md` using the template from Task 1.1 before tagging. Reference the note from the changelog section. Regenerate mirrors.
+  - Files: `.rulesync/skills/release/SKILL.md`, generated mirrors
+  - Depends on: Task 1.1
+  - Acceptance: the step lists the four triggering changelog headings; `bun run rules:check` exits 0.
+
+- [ ] **Task 4.2**: Add the CI enforcement check
+  - Description: Add a check (script plus a job in `.github/workflows/repo-policies.yml`, or a step in `publish-on-tag.yml` that runs before publishing) that reads the changelog section for the tag being released and fails if it contains a breaking/deprecated/removed/changed entry while `mcp-server/src/docs/upgrades/<version>.md` does not exist. Write it as a Bun TypeScript script with `const` arrow functions and explicit return types, following the repo's script conventions. Include tests for: note present and required, note missing and required, note not required.
+  - Files: `scripts/check-upgrade-notes.ts` (new), `package.json`, `.github/workflows/repo-policies.yml` or `.github/workflows/publish-on-tag.yml`, tests
+  - Depends on: Task 4.1
+  - Acceptance: all three test cases pass; the check fails a simulated release with a breaking changelog entry and no note; `bun run lint` passes.
+
+- [ ] **Task 4.3**: Link notes from the changelog
+  - Description: Update `CHANGELOG.md` so each version section with an upgrade note links it. Add a line to the changelog header explaining that upgrade notes live in `mcp-server/src/docs/upgrades/` and are also available through the MCP server's `terreno_get_upgrade_guide` tool.
+  - Files: `CHANGELOG.md`
+  - Depends on: Task 1.3
+  - Acceptance: every version with a note links it; the header explains where notes live and how to fetch them.
+
+## Phase 5: Validation
+
+- [ ] **Task 5.1**: Perform a real multi-version upgrade with the skill
+  - Description: Create a consumer app pinned to an older Terreno version (at least two minors behind current — scaffold with `terreno_bootstrap_app` from that version, or check out `example-frontend`/`example-backend` at the older tag into a scratch directory). Run the `upgrading-terreno` skill to bring it to current. Verify: the clean-tree precondition fires when the tree is dirty, the confirmation gate fires, each phase's verification runs, and the app compiles and runs afterward. Record every gap and fix the skill, the notes, or the how-to as appropriate. Capture the transcript and the running upgraded app to `/opt/cursor/artifacts/`.
+  - Files: `.rulesync/skills/upgrading-terreno/SKILL.md`, `mcp-server/src/docs/upgrades/*`, `docs/how-to/upgrade-terreno.md`, generated mirrors
+  - Depends on: Task 3.5, Task 1.3
+  - Acceptance: the upgrade succeeds and the app runs; both gates observed firing; every gap fixed; artifacts captured; `bun run rules:check` exits 0.
+
+- [ ] **Task 5.2**: Verify the failure-isolation path
+  - Description: Deliberately create a failing upgrade (for example by pinning a consumer file to an API removed in the range) and confirm the skill stops at the failing phase, names it, reports what succeeded, offers rollback, and — for a multi-version range — retries version by version to isolate the breaking version. Fix the skill if any of those behaviors is missing.
+  - Files: `.rulesync/skills/upgrading-terreno/SKILL.md`, generated mirrors
+  - Depends on: Task 5.1
+  - Acceptance: all four failure behaviors observed in the transcript; the isolation retry correctly identifies the breaking version; `bun run rules:check` exits 0.

package/src/docs/versioned/0.30.0/tasks/web-ssr-and-admin-spa.md

@@ -0,0 +1,155 @@
+# Task List: Server-Side Rendering for Universal Web (and Admin SPA)
+
+See: [`docs/implementationPlans/web-ssr-and-admin-spa.md`](../implementationPlans/web-ssr-and-admin-spa.md)
+
+**RTK deprecation flag:** **Partial.** Phase 0 must run after PR #869 merges, because whether the local-first client can be kept out of the server render path is the main feasibility question. Tasks marked `[RTK]` touch the data layer directly.
+
+**Prerequisite:** Expo SDK ≥ 55. The repo catalog is on `~54.0.29`; PR [#779](https://github.com/flourishhealth/terreno/pull/779) upgrades to SDK 56. Verify the merged Expo version before starting and stop if it is below 55.
+
+## Instructions for the implementing agent
+
+- **Phase 0 is a gate, not a formality.** If the spike shows that `static` output cannot work without unreasonable changes, write the report, update the IP with the finding, and stop. A well-documented no-go is a successful outcome for Phase 0.
+- Do not modify `@terreno/ui` component behavior to make SSR work. If a component needs a browser API, guard the access; do not change what it renders in the browser.
+- Every SSR-safety fix needs a test that fails before the fix.
+- Server rendering is **alpha** in Expo SDK 55+. Treat upstream bugs as expected; record them with links rather than working around them silently.
+- Run `bun run compile`, `bun run lint`, and `bun run ui:test` before each commit.
+
+## Phase 0: Feasibility spike
+
+- [ ] **Task 0.1**: Verify prerequisites
+  - Description: Confirm the Expo version in the root `package.json` catalog is ≥ 55 and that PR #869 is merged. Record both. If Expo is below 55, stop and report that this IP is blocked on PR #779. Read the current Expo documentation for `web.output` modes and server rendering and record the alpha status and any stated limitations.
+  - Files: none (findings in the PR body)
+  - Depends on: PR #779 and PR #869 merged
+  - Acceptance: both versions recorded with citations; the upstream alpha status and its documented limitations are captured; a stop decision is made explicitly if prerequisites are unmet.
+
+- [ ] **Task 0.2**: Attempt `static` output on `example-frontend`
+  - Description: On a scratch branch, set `web.output` to `static` in `example-frontend`'s app config and run the web export. Record every error and warning in full. For each failure, identify the root cause: a `@terreno/ui` component touching a browser global, a native-only import, a font-loading issue, a provider issue, or the syncdb client initializing at module scope. Do not fix anything yet — the goal is a complete inventory of the work.
+  - Files: none (scratch branch, not committed)
+  - Depends on: Task 0.1
+  - Acceptance: the export was attempted and every failure captured verbatim with its root cause classified; the scratch branch is not merged.
+
+- [ ] **Task 0.3**: `[RTK]` Determine whether the syncdb client can be excluded from server render
+  - Description: The syncdb client depends on IndexedDB and Web Crypto, neither of which exists on the server. Read the merged syncdb client initialization code and determine: whether it initializes at module scope or on provider mount, whether it already guards for a non-browser environment, and what would be required to make it a no-op during server render while hydrating correctly on the client. This is the highest-risk unknown in the IP. Write the finding with file citations.
+  - Files: none (findings in the PR body)
+  - Depends on: Task 0.2
+  - Acceptance: the initialization path is traced with file and line citations; a concrete answer is given on whether exclusion is possible and what it costs; if it is not possible without syncdb changes, that requirement is written up as a dependency.
+
+- [ ] **Task 0.4**: Write the feasibility report and go/no-go
+  - Description: Create `docs/implementationPlans/web-ssr-feasibility.md` containing: the prerequisite state, the full failure inventory from Task 0.2 classified by root cause with an effort assessment per class, the syncdb finding from Task 0.3, the risks that turned out to be real versus imagined against the IP's risk table, and an explicit recommendation — proceed with `static`, proceed with `static` and `server`, defer, or abandon with reasons. Update the IP's risk table and phases to match reality.
+  - Files: `docs/implementationPlans/web-ssr-feasibility.md` (new), `docs/implementationPlans/web-ssr-and-admin-spa.md`
+  - Depends on: Task 0.3
+  - Acceptance: the report contains an unambiguous recommendation; the IP's risk table is corrected against what was actually observed; every subsequent phase is either confirmed, rescoped, or cancelled in the IP.
+
+## Phase 1: SSR-safety audit and fixes
+
+- [ ] **Task 1.1**: Build a server-render test harness
+  - Description: Create `ui/src/__tests__/serverRender.test.tsx` that renders components with `react-dom/server`'s `renderToString` (or the equivalent supported path for `react-native-web`) in an environment where `window`, `document`, and `localStorage` are undefined. The harness should iterate every component exported from `ui/src/index.tsx` and assert each renders without throwing. Components that legitimately cannot render without a browser get an explicit allowlist entry with a comment explaining why — the allowlist is the audit output.
+  - Files: `ui/src/__tests__/serverRender.test.tsx` (new)
+  - Depends on: Task 0.4 (go decision)
+  - Acceptance: the harness covers every export from `ui/src/index.tsx`; failures are listed rather than skipped; the allowlist has a justification per entry; `bun run ui:test` runs it.
+
+- [ ] **Task 1.2**: Fix SSR-unsafe components
+  - Description: For each failure the harness finds, guard the browser-API access rather than changing render output. Follow the existing precedent in the repo (the client storage layer's `typeof window` checks). Do not change any component's browser behavior. Each fix must make a previously-failing harness case pass, and no existing `@terreno/ui` test may change behavior.
+  - Files: `ui/src/**`
+  - Depends on: Task 1.1
+  - Acceptance: the harness passes with an allowlist containing only genuinely browser-dependent components; `bun run ui:test` passes with no changed assertions in existing tests; browser behavior is unchanged (verified by the existing test suite).
+
+- [ ] **Task 1.3**: Verify theme and font determinism
+  - Description: Render a component tree wrapped in `TerrenoProvider` twice in the server harness and assert identical output, proving theme resolution is deterministic. Check the font-loading path for anything that would differ between server and client render. Fix any non-determinism (for example a value derived from the current time or a random id) and add the test.
+  - Files: `ui/src/__tests__/serverRender.test.tsx`, `ui/src/Theme.tsx` or `ui/src/TerrenoProvider.tsx` if a fix is needed
+  - Depends on: Task 1.2
+  - Acceptance: two server renders of the same tree produce byte-identical output; any non-determinism found is fixed and covered by the test.
+
+- [ ] **Task 1.4**: `[RTK]` Guard the data-layer client against server render
+  - Description: Implement the exclusion determined in Task 0.3 so the syncdb client does not initialize during server render, and hydrates normally on the client. Add a test asserting that importing and rendering the provider in the server harness does not attempt IndexedDB or Web Crypto access. If Task 0.3 concluded this requires changes inside `@terreno/syncdb`, make the minimal change there with its own test.
+  - Files: `syncdb/src/**` and/or the provider wiring, plus tests
+  - Depends on: Task 1.3, Task 0.3
+  - Acceptance: the server harness renders the provider without touching IndexedDB or Web Crypto; the client still initializes correctly in the browser (verified by an existing or new client-side test); `bun run compile` passes.
+
+## Phase 2: `static` output for `admin-spa`
+
+- [ ] **Task 2.1**: Add output-mode support to the admin serve plugin
+  - Description: Locate `AdminSpaServeApp` (confirm the file path — it is registered in `example-backend/src/server.ts`) and add support for serving a `static`-output build: per-route HTML files rather than a single `index.html` fallback. The existing `single`-output behavior must remain the default and continue working unchanged so consumers upgrading Terreno without rebuilding their admin are unaffected. Add tests for both modes, including the fallback behavior for unknown routes.
+  - Files: the `AdminSpaServeApp` source file, tests
+  - Depends on: Task 1.2
+  - Acceptance: both output modes serve correctly; `single` remains the default; a request for an unknown route behaves correctly in each mode; tests cover both.
+
+- [ ] **Task 2.2**: Build `admin-spa` with `static` output
+  - Description: Change `admin-spa`'s app config to `static` output and build it. Fix whatever breaks in `admin-spa/src/**` following the same guard-rather-than-change discipline from Phase 1. Verify every admin route produces an HTML file and that the app still functions after hydration — list models, open a form, save a record.
+  - Files: `admin-spa/app.json` or `admin-spa/app.config.ts`, `admin-spa/src/**`
+  - Depends on: Task 2.1
+  - Acceptance: the build produces per-route HTML; every admin route loads; list, form, and save all work after hydration; no hydration mismatch warnings in the console.
+
+- [ ] **Task 2.3**: Update the admin integration workflow
+  - Description: Update `.github/workflows/admin-spa-integration.yml` to build and exercise the `static` output. If the workflow currently asserts single-`index.html` behavior, extend it to cover both modes rather than replacing the existing coverage.
+  - Files: `.github/workflows/admin-spa-integration.yml`
+  - Depends on: Task 2.2
+  - Acceptance: the workflow passes; both output modes are exercised; existing coverage is retained.
+
+## Phase 3: `static` output for `example-frontend`
+
+- [ ] **Task 3.1**: Switch `example-frontend` to `static` output
+  - Description: Set `web.output` to `static`, build, and fix remaining failures. Verify every route produces HTML with meaningful content by fetching each route with JavaScript disabled and confirming visible text is present in the response body — not just an empty shell. Confirm no hydration mismatch warnings appear on any route.
+  - Files: `example-frontend/app.json`, `example-frontend/**` as needed
+  - Depends on: Task 1.4, Task 2.2
+  - Acceptance: every route returns HTML containing meaningful content with JavaScript disabled; no hydration warnings on any route; the app functions normally with JavaScript enabled.
+
+- [ ] **Task 3.2**: Update the frontend deploy workflow and hosting config
+  - Description: Update `.github/workflows/frontend-example-deploy.yml` and the hosting configuration for the new output shape. `static` output produces per-route HTML, so the SPA-fallback rewrite that `single` required may now be wrong for some paths — verify the host's routing behavior and adjust. Update `example-frontend/vercel.json` from [`deploy-to-vercel`](../implementationPlans/deploy-to-vercel.md) if its rewrites conflict with per-route HTML.
+  - Files: `.github/workflows/frontend-example-deploy.yml`, `example-frontend/vercel.json`, hosting config
+  - Depends on: Task 3.1
+  - Acceptance: the deployed example serves per-route HTML; deep links resolve; the SPA-fallback rewrite no longer shadows real route files; the deploy workflow passes.
+
+## Phase 4: `server` output with the Express adapter
+
+- [ ] **Task 4.1**: Prototype the Express adapter inside `@terreno/api`
+  - Description: Only if Task 0.4 recommended proceeding to `server` output. Build a prototype mounting `expo-server/adapter/express` in the Terreno Express app: serve `dist/client` statically and delegate remaining requests to the server bundle. Verify the exact adapter import path and `createRequestHandler` parameters against current Expo documentation. Establish route precedence: API routes, auth routes, and the admin mount must all match before the SSR catch-all. Add tests asserting precedence — a request to an API path must never reach the SSR handler.
+  - Files: `api/src/` (new plugin or serve module), tests
+  - Depends on: Task 3.1, Task 0.4
+  - Acceptance: SSR renders through the Express app; precedence tests prove API, auth, and admin routes are never shadowed; the adapter import path is verified against current Expo docs and cited.
+
+- [ ] **Task 4.2**: `[RTK]` Handle the unauthenticated-shell render
+  - Description: Per IP question S3, v1 renders the unauthenticated shell on the server and hydrates to the real state on the client. Implement that explicitly rather than by accident: ensure no server render depends on session state, and verify there is no visible flicker of authenticated content. Document the tradeoff in the how-to guide. If the flicker is unacceptable in practice, record that finding and scope a follow-up rather than expanding this IP.
+  - Files: `api/src/` SSR module, `example-frontend/app/_layout.tsx`, docs
+  - Depends on: Task 4.1
+  - Acceptance: server-rendered HTML never contains authenticated content; the hydration transition is observed and characterized (acceptable or not) with a screenshot or recording; the tradeoff is documented.
+
+- [ ] **Task 4.3**: Document Expo Router API routes narrowly
+  - Description: Per IP question S6, document that `server` output enables Expo Router API routes and that they should be used only for web-specific concerns — OG image generation, web-only redirects — with an explicit statement that business logic, data access, and auth belong in `@terreno/api`. Include one worked example (an OG image route) and a "do not put this here" list.
+  - Files: `docs/how-to/enable-web-ssr.md`
+  - Depends on: Task 4.1
+  - Acceptance: the boundary is stated unambiguously; one worked example present; the "do not" list names data access, auth, and business logic.
+
+## Phase 5: Data loading design
+
+- [ ] **Task 5.1**: `[RTK]` Design pass on server-render data loading
+  - Description: Research and write a design note on how server-rendered routes should obtain data given a local-first client: how Expo Router data loaders (`useLoaderData`) interact with a client whose source of truth is a local encrypted store, whether server-fetched data should seed the local store or bypass it, what happens on hydration when local data differs from server-rendered data, and how permissions are enforced when the renderer is inside the API process. Output a recommendation and, if the work is substantial, a new IP rather than expanding this one.
+  - Files: `docs/implementationPlans/ssr-data-loading.md` (new) or a section in the feasibility report
+  - Depends on: Task 4.2
+  - Acceptance: all four questions are answered with a recommendation; if the recommendation implies substantial work, a separate IP is created and this IP's scope is closed at Phase 4.
+
+## Phase 6: Documentation and defaults
+
+- [ ] **Task 6.1**: Write `docs/explanation/web-rendering-modes.md`
+  - Description: Explainer covering all rendering modes (`single`, `static`, `server`) with honest tradeoffs: SEO, first paint, hosting requirements, operational complexity, and what each costs. State which modes Terreno supports as of this work and which are recommended for which situation. Include the "why does a React Native framework care about SSR" framing, since the answer is not obvious to readers who think of Terreno as mobile-first.
+  - Files: `docs/explanation/web-rendering-modes.md` (new), `docs/explanation/README.md`
+  - Depends on: Task 3.1
+  - Acceptance: all three modes covered with at least four tradeoff dimensions each; supported modes stated accurately; the framing section present.
+
+- [ ] **Task 6.2**: Write `docs/how-to/enable-web-ssr.md`
+  - Description: How-to taking a reader from `single` to `static`, and to `server` if it shipped. Cover: the app-config change, what changes in the build output, the hosting change required for each mode, how to verify (fetch a route with JavaScript disabled), common failures (hydration mismatches, browser globals in custom components, the SPA-fallback rewrite shadowing route files), and how to roll back.
+  - Files: `docs/how-to/enable-web-ssr.md` (new), `docs/how-to/README.md`
+  - Depends on: Task 6.1, Task 4.3
+  - Acceptance: a reader can follow it to switch modes; the verification step is concrete; at least three common failures documented with symptoms; rollback included.
+
+- [ ] **Task 6.3**: Update deployment documentation and the output-mode table
+  - Description: Update `docs/explanation/deployment-baseline.md`'s output-mode table for the modes that now ship, and update both provider guides ([`deploy-to-vercel`](../implementationPlans/deploy-to-vercel.md), [`deploy-to-gcp`](../implementationPlans/deploy-to-gcp.md)) for the hosting implications. GCP is affected most: `server` output cannot be served from a GCS bucket, so the GCP guide needs a Cloud Run web-serving option.
+  - Files: `docs/explanation/deployment-baseline.md`, `docs/how-to/deploy-web-to-vercel.md`, `docs/how-to/deploy-web-to-gcs-cdn.md`, possibly a new `docs/how-to/deploy-web-to-cloud-run.md`
+  - Depends on: Task 6.2
+  - Acceptance: the output-mode table matches shipped reality; the GCS guide states that `server` output cannot be hosted there and links the alternative; both provider guides are consistent with the modes that shipped.
+
+- [ ] **Task 6.4**: Decide and implement the default output mode
+  - Description: Per IP question S5, decide whether `static` becomes the default for new apps. If yes: update the bootstrap templates in `mcp-server/src/docs/templates/bootstrap/`, write an upgrade note explaining the change and how to keep `single`, and update the deployment guides. If no: record the decision and its reason in the explainer. Do not change the default without an upgrade note.
+  - Files: `mcp-server/src/docs/templates/bootstrap/**`, `mcp-server/src/docs/upgrades/<version>.md`, `docs/explanation/web-rendering-modes.md`
+  - Depends on: Task 6.3
+  - Acceptance: the decision is recorded with reasoning; if the default changed, a bootstrapped app builds and deploys with the new default and an upgrade note exists; `bun run mcp:build` succeeds.

package/src/docs/versioned/next/explanation/README.md

@@ -2,13 +2,19 @@
 
 Understanding-oriented documentation: concepts, architecture, and context.
 
+## Deployment
+
+- [Deployment baseline](deployment-baseline.md) — seven requirements for production Terreno apps
+- [GCP deployment architecture](deployment-architecture-gcp.md) — Cloud Run + GCS/CDN topology and tradeoffs
+- [GCP hosting architecture](gcp-hosting-architecture.md) — static site hosting with GCS and Cloud CDN (legacy detail)
+
 ## Contents
 
 - [AI-powered workflows](ai-workflows.md) — Autonomous documentation, testing, and maintenance workflows
 - [Authentication architecture](authentication.md) — How JWT, OAuth, and token refresh work
 - [Configuration system](configuration-system.md) — Runtime configuration with database persistence
 - [Dependency management](dependency-management.md) — Dependabot, auto-merge, and security practices
-- [GCP hosting architecture](gcp-hosting-architecture.md) — Static site hosting with GCS and Cloud CDN
 - [Modular API design](modular-api-design.md) — 🚧 Why TerrenoApp replaces setupServer
 - [modelRouter actions](model-router-actions.md) — Named collection and instance operations on modelRouter
 - [No barrel imports](no-barrel-imports.md) — Import concrete modules, not `index` re-export barrels
+- [Positioning](positioning.md) — Canonical copy blocks and the honest Django/Rails comparison

package/src/docs/versioned/next/explanation/deployment-architecture-gcp.md

@@ -0,0 +1,65 @@
+# GCP deployment architecture
+
+Reference topology for hosting a Terreno full-stack app on Google Cloud Platform.
+
+This page is conceptual — commands live in the [how-to guides](../how-to/deploy-to-gcp.md).
+
+## Topology
+
+```mermaid
+flowchart TD
+  U["User<br/>iOS / Android / Web"]
+  CDN["Cloud CDN + GCS bucket<br/>expo export -p web output"]
+  CR["Cloud Run<br/>@terreno/api backend"]
+  SM["Secret Manager<br/>auth secrets, MONGO_URI"]
+  AT["MongoDB Atlas<br/>replica set (change streams)"]
+  GCS["GCS bucket<br/>user file uploads"]
+  AR["Artifact Registry<br/>backend image"]
+  U -->|"web"| CDN
+  U -->|"native app"| CR
+  CDN -->|"API calls"| CR
+  CR --> SM
+  CR --> AT
+  CR --> GCS
+  AR --> CR
+```
+
+## Component responsibilities
+
+| Component | Role |
+|-----------|------|
+| **Artifact Registry** | Stores versioned backend container images built from `example-backend/Dockerfile` |
+| **Cloud Run** | Runs the long-lived `@terreno/api` process (HTTP + Socket.io) |
+| **Secret Manager** | Holds `MONGO_URI`, JWT secrets, and other credentials — mounted as env vars |
+| **MongoDB Atlas** | Primary database; must be a replica set for change streams (realtime, feature flags) |
+| **GCS (web bucket)** | Serves static web export; CDN caches at the edge |
+| **GCS (uploads bucket)** | Private object storage for user uploads via `@terreno/api` file plugins |
+
+## Why Cloud Run (not App Engine or GKE)
+
+| Option | Tradeoff |
+|--------|----------|
+| **Cloud Run** | Pay-per-use, minimal ops, supports WebSockets with session affinity — fits Terreno's socket + HTTP model |
+| **App Engine** | Similar serverless model but less flexible for custom containers and long timeouts |
+| **GKE** | Full control but requires cluster management — overkill for a single Terreno backend |
+
+## Why Atlas (not self-hosted Mongo on GCP)
+
+| Option | Tradeoff |
+|--------|----------|
+| **MongoDB Atlas** | Managed replica sets, backups, and change streams out of the box |
+| **Self-hosted on Compute Engine** | You operate replica set elections, backups, and upgrades — documented as out of scope for launch |
+
+## Static web vs server-rendered
+
+| Approach | Tradeoff |
+|----------|----------|
+| **GCS + CDN (static export)** | Cheapest, simplest, works today with Expo `single`/`static` output — no SSR or API routes |
+| **Node/Bun server (SSR)** | Better SEO and API routes — requires Expo SDK ≥ 55; not available in the current `~54` catalog |
+
+Native iOS and Android apps call Cloud Run directly; only the web client uses the CDN origin.
+
+## Related
+
+- [Deployment baseline](deployment-baseline.md) — seven requirements every host must satisfy
+- [Deploy to GCP](../how-to/deploy-to-gcp.md) — step-by-step guides

package/src/docs/versioned/next/explanation/deployment-baseline.md

@@ -0,0 +1,78 @@
+# Deployment baseline
+
+Every Terreno production deployment needs the same seven foundations. Provider guides ([Deploy to GCP](../how-to/deploy-to-gcp.md), future Vercel guide) map these to specific platforms; this page names them once.
+
+See also the [environment variables reference](../reference/environment-variables.md).
+
+## Seven baseline requirements
+
+| # | Requirement | Why Terreno needs it | When missing |
+|---|-------------|----------------------|--------------|
+| 1 | **MongoDB replica set** | Change streams power realtime and live feature-flag updates | Startup logs: `FeatureFlag.watch() failed — live updates require MongoDB as a replica set` (`feature-flags/src/featureFlagsApp.ts`) |
+| 2 | **Auth secrets** | JWT signing and sessions (or Better Auth encryption) | Login fails; tokens rejected |
+| 3 | **Long-lived backend process** | Socket.io connections are not request/response | Websockets drop on platforms with short request timeouts or aggressive scale-to-zero |
+| 4 | **Correct origins** | CORS and Better Auth `trustedOrigins` must include your web and native schemes | Browser: blocked by CORS; native: auth redirects fail |
+| 5 | **Build-time client config** | `EXPO_PUBLIC_*` values are inlined into the web bundle at build time | API calls go to `undefined` or localhost after deploy — see [Build for web](../how-to/build-for-web.md) |
+| 6 | **Health endpoint** | Load balancers and orchestrators need readiness probes | Platform marks the service unhealthy and stops routing traffic |
+| 7 | **Durable file storage** | Uploads must not live on ephemeral container disk | Files disappear on restart; use GCS/S3 and credentials |
+
+Requirements **1**, **3**, and **5** are the ones teams miss most often.
+
+### Symptom details
+
+**1 — Standalone MongoDB**
+
+Terreno's feature-flag plugin opens a change stream on startup. Without a replica set, live flag sync is disabled and logs:
+
+```text
+[feature-flags] FeatureFlag.watch() failed — live updates require MongoDB as a replica set (even single-node).
+```
+
+Use [MongoDB Atlas](https://www.mongodb.com/atlas) or a single-node replica set for development.
+
+**3 — Short-lived serverless timeouts**
+
+The RTK/socket client enables reconnection (`reconnection: true`, `reconnectionAttempts: 5` in `rtk/src/socket.ts`). When the backend drops idle connections (for example Cloud Run's default 300s request timeout), clients reconnect but realtime state may lag until the new socket attaches.
+
+**5 — Build-time API URL**
+
+If you set `EXPO_PUBLIC_API_URL` only at runtime on the static host, the bundle still contains whatever was present at `bun run export` time — often `http://localhost:4000`. The browser then fails network requests against localhost.
+
+## Web output modes
+
+Expo Router supports three web output modes. The choice determines hosting options.
+
+| Mode | Output | API routes | SSR | Hosting | Terreno status |
+|------|--------|-----------|-----|---------|----------------|
+| `single` | One `index.html` SPA | No | No | Any static host | **Current default** |
+| `static` | Per-route HTML files | No | No | Any static host | Available; better SEO |
+| `server` | `dist/client` + `dist/server` | Yes | Yes (alpha, SDK ≥ 55) | Node/Bun/edge runtime | Not yet — repo catalog is Expo `~54.0.29`; see [Web SSR and admin SPA](https://github.com/FlourishHealth/terreno/blob/master/docs/implementationPlans/web-ssr-and-admin-spa.md) |
+
+## Multi-environment checklist
+
+Staging and production differ in these values (each environment needs its **own web build** because of `EXPO_PUBLIC_API_URL`):
+
+| Item | Where to configure |
+|------|-------------------|
+| Secret values | Platform secret store / Secret Manager |
+| `MONGO_URI` | Separate cluster or database per environment |
+| `EXPO_PUBLIC_API_URL` | Set before `bun run export` — one build per environment |
+| `corsOrigin` | `setupServer({ corsOrigin })` in backend |
+| Better Auth `trustedOrigins` + `BETTER_AUTH_URL` | Better Auth config / env |
+| Feature-flag defaults | MongoDB documents or seed scripts |
+
+## Containerizing the backend
+
+The canonical Dockerfile is [`example-backend/Dockerfile`](https://github.com/FlourishHealth/terreno/blob/master/example-backend/Dockerfile). It:
+
+1. Installs workspace dependencies and compiles packages in dependency order.
+2. Builds a Bun-compiled binary for production.
+3. Runs as a non-root user and exposes `/health` via `@terreno/api-health`.
+
+Three details consumers get wrong:
+
+- **`PORT`** — Cloud Run and other platforms assign the listen port via `PORT`. Terreno reads `process.env.PORT` in `api/src/terrenoApp.ts` (default `9000` if unset).
+- **Non-root** — Do not run the container as root in production.
+- **Compile order** — Workspace packages (`@terreno/api`, `@terreno/test`, etc.) must compile before the example backend bundles.
+
+CI builds the image on every PR that touches backend paths (`.github/workflows/example-backend-docker.yml`).

package/src/docs/versioned/next/explanation/positioning.md

@@ -0,0 +1,164 @@
+# Positioning
+
+This is the single source of truth for how Terreno describes itself. The problem
+this page exists to fix is drift: the README, the docs landing page, `AGENTS.md`,
+and the npm package descriptions have historically said different things, so a
+visitor's impression of Terreno depended on which door they walked through.
+
+The rule is simple: **write the wording once, here, then reuse it verbatim
+everywhere else.** Do not paraphrase per surface.
+
+## Canonical copy blocks
+
+Copy these blocks exactly. They are in fenced code blocks so they can be lifted
+without markdown-rendering surprises.
+
+### `tagline`
+
+Used by: README H1 subtitle, docs site `tagline`, npm `description` prefix.
+
+```
+Terreno is Django/Rails for TypeScript — with universal app support.
+```
+
+### `elevator`
+
+Used by: README intro, docs landing intro, package READMEs.
+
+```
+Terreno is Django/Rails for TypeScript — a batteries-included, full-stack
+framework where the undifferentiated 80% of an app is already written. On the
+backend you get Mongoose models, auto-generated REST APIs, permissions, an admin
+panel, authentication, and an AI service. On the frontend you get one universal
+app — a single React Native codebase that ships to iOS, Android, and web. It is
+built to be driven by AI coding agents from the first prompt to a production
+deploy.
+```
+
+### `pillars`
+
+Used by: README, docs landing, `AGENTS.md`. Keep the order.
+
+```
+- Batteries included — auth, CRUD APIs, admin, permissions, AI, realtime,
+  feature flags, and consent are already built, so your code is business logic.
+- Universal by default — one React Native codebase ships to iOS, Android, and
+  web. Not a web framework with a mobile bolt-on.
+- AI-native — agents are a first-class client of the framework, not an
+  afterthought.
+```
+
+### `aiPillar`
+
+Used wherever the AI-native pillar gets more than a bullet. It must always name
+**both** layers (see language rule 5).
+
+```
+Terreno's AI-native story has two layers. The tool layer is a Model Context
+Protocol (MCP) server that gives coding agents codegen, documentation search,
+and component reference for the framework's conventions. The process layer is the
+`/terreno-*` SDLC pipeline — plan, implement test-first, verify in a fresh
+context, submit with evidence, then own the review loop — which today runs inside
+the Terreno repository while its consumer-installable packaging is finished.
+Django gives you `manage.py startapp`; Terreno is building a reviewed path from a
+request to a mergeable pull request.
+```
+
+> **Portability gate (do not remove until cleared).** The `/terreno-*` pipeline
+> is not yet verified to run in a consumer application — that is
+> [`agentic-sdlc-plugin`](../implementationPlans/agentic-sdlc-plugin.md) Task 2.5,
+> which is still open. Until it passes, describe the pipeline as in-progress
+> packaging (as the `aiPillar` block above does) and never imply a consumer can
+> install and run it today. When Task 2.5 passes, update the `aiPillar` block to
+> claim the pipeline as consumer-ready.
+
+### `pitch`
+
+Used by: blog post intros, conference abstracts, social. ~150 words.
+
+```
+Every app needs the same foundation: authentication, user management, CRUD APIs,
+an admin panel, permissions, realtime updates, feature flags, and AI. That work
+is weeks of undifferentiated effort, and it is the same in every product.
+
+Terreno is Django/Rails for TypeScript. Define a Mongoose model, register it, and
+you have a permissioned REST API with pagination, filtering, and an OpenAPI spec.
+Add the admin package and you have a working admin panel. Your app is left with
+the part that is actually yours: the business logic.
+
+The difference from Django or Rails is universal apps — one React Native codebase
+ships to iOS, Android, and web — and being AI-native. Agents are a first-class
+client: an MCP server teaches them the conventions, and a reviewed SDLC pipeline
+takes a request to a mergeable pull request. You build with AI from the first
+prompt to production.
+```
+
+## Why the Django/Rails analogy
+
+Django and Rails won by deciding that the generic parts of a web app — the ORM,
+the router, the admin, auth — belong in the framework, not in every project. They
+are opinionated, batteries-included, and productive because of it. Terreno makes
+the same bet for TypeScript: the generic 80% of an app lives in the framework so
+your codebase is the 20% that is unique to your product.
+
+The analogy earns two honest caveats. First, Terreno targets a document store
+(MongoDB via Mongoose), not a relational ORM, and it has no migrations framework.
+Second, it is younger — several Django/Rails staples (background jobs,
+server-side rendering, role-based access control) are not shipped yet. The
+comparison table below is deliberately straight about where the analogy holds and
+where it does not; being honest about the gaps is what makes the analogy credible
+rather than marketing.
+
+The two things Django and Rails do not give you, and Terreno does, are **universal
+apps** (one codebase for iOS, Android, and web) and being **AI-native** by design.
+
+## Comparison table
+
+Every "shipped" row cites where the feature lives in the source. Every "not
+shipped" row links the implementation plan or roadmap item that tracks it.
+
+| Django / Rails concept | Terreno equivalent | Honest caveat |
+|------------------------|--------------------|----------------|
+| Models + ORM | Mongoose schemas + `@terreno/api` plugins (`api/src/plugins.ts`) | Document store, not relational; no migrations framework (see the Migrations row) |
+| `ModelViewSet` / scaffolds | `modelRouter` (`api/src/api.ts`) | REST only; no GraphQL |
+| Django admin | `@terreno/admin-backend` + `@terreno/admin-frontend` / `@terreno/admin-spa` | Younger; the parity gap is tracked in [`admin-ui-v2-django-parity`](../implementationPlans/admin-ui-v2-django-parity.md) |
+| Auth + permissions | Better Auth (`api/src/betterAuthApp.ts`) + `Permissions` (`api/src/permissions.ts`) | Fine-grained RBAC is in progress ([`rbac-permissions`](../implementationPlans/rbac-permissions.md)) |
+| Templates / views | `@terreno/ui` components — one universal codebase for iOS, Android, and web | Server-side rendering for web is not shipped yet ([`web-ssr-and-admin-spa`](../implementationPlans/web-ssr-and-admin-spa.md)) |
+| `manage.py` / generators | MCP server tools — the *tool* layer (`mcp-server/src/tools.ts`) + the `/terreno-*` SDLC pipeline — the *process* layer (`plugins/terreno-planning/skills/`) | Agent-driven rather than CLI-driven; the pipeline is not yet packaged for consumer apps ([`agentic-sdlc-plugin`](../implementationPlans/agentic-sdlc-plugin.md) Task 2.5) |
+| Celery / ActiveJob (background jobs) | Not shipped | On the [roadmap](../../ROADMAP.md) |
+| Migrations | No migrations framework | Schema evolution is convention plus the `mongoose-schema-safety` skill (`.claude/skills/mongoose-schema-safety/`) |
+
+## Language rules
+
+Every doc, README, landing page, and agent-facing surface follows these rules.
+
+1. **Lead with the analogy.** Say "Django/Rails for TypeScript" within the first
+   two sentences of the README and the docs landing page.
+2. **Say "universal app,"** not "cross-platform" and not "React Native app," when
+   describing the frontend. It is one codebase that ships to iOS, Android, and
+   web.
+3. **Never claim an unshipped feature as available.** If a capability is on the
+   roadmap or tracked by an open IP, say so. Grep the package source before
+   writing that something ships.
+4. **Keep superlatives off reference pages.** "The best framework for X" belongs
+   on the landing page and the pitch, never in reference documentation.
+5. **Never describe one AI layer without the other.** The tool layer (MCP server)
+   and the process layer (`/terreno-*` pipeline) are always named together, and
+   the pipeline is described honestly per the portability gate above.
+
+## Repository metadata (maintainer action)
+
+The GitHub repository description and topics cannot be set from a commit. A
+maintainer must set them in **Settings → General** and the **About** panel.
+
+**Description** (the short tagline variant):
+
+```
+Django/Rails for TypeScript, with universal iOS/Android/web apps.
+```
+
+**Topics:**
+
+```
+typescript, react-native, expo, express, mongoose, framework, mcp, ai, universal-apps, full-stack
+```