docs(rfc): rethink database architecture for Prisma 8

.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/briefs/claude-opus-architecture-finish.md

@@ -0,0 +1,45 @@
+# Claude Opus 5 High — Immediate Architecture Report Synthesis
+
+Resume native Claude Code session `f79af5bb-e953-4aae-9585-a1c83e73a00d` at Opus 5, effort high.
+This is the terminal synthesis turn for the independent architecture lane.
+
+The original and resumed workflow produced extensive specialist evidence. Multiple agents completed
+NetScript current-state, doctrine/process, generated-pipeline, documentation-claim, git-history/LOC,
+Prisma control/runtime, migration, contract, and adversarial fact-check work; a few children were
+lost or killed at process boundaries. The interactive background parent then exited at a bridge
+boundary before replacing its report placeholder.
+
+Do not launch or resume any Agent, Task, Workflow, Team, monitor, or child session. Do not repeat
+the broad research. Use the completed specialist results preserved in the current conversation plus
+the three committed research documents. Perform only a narrowly targeted read if a claim would
+otherwise be unsupported.
+
+Replace exactly this file:
+
+`.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/research/claude-opus-architecture-review.md`
+
+with the complete decision-grade independent architecture report required by the original brief. It
+must include:
+
+1. requested/observed provider, model, effort, parent session/handle chain, workflow roles, and
+   observable specialist identifiers/statuses;
+2. verdict and architectural thesis;
+3. target package/ownership graph with NetScript doctrine/archetype assignment;
+4. target/config/schema-space/migration/runtime identities and invariants;
+5. concrete TypeScript public API, definition DSL, contribution DSL, factory/port, and generated
+   composition-root sketches;
+6. plugin contribution/extensibility protocol, ownership/conflict/dependency/version/removal rules;
+7. typed plan/apply/result/progress/error command lifecycle, locks, concurrency, recovery, CI,
+   offline determinism, and agent-facing manifest/surface;
+8. Prisma 8 adopt/wrap/reject/defer decisions and a volatility-containment boundary;
+9. provider matrix and multi-target/multi-schema/multi-engine behavior without false portability;
+10. clean-break migration/cutover and parallel-branch strategy with data safety but no runtime
+    compatibility shims;
+11. conformance, generated-project, journey, negative-path, migration, release, and GA gates;
+12. risks, rejected alternatives, unresolved questions, explicit decision checkpoints, and exact
+    local/primary source references.
+
+Correct known precision issues: the root catalog entries are `^7.8.0`, generated templates use
+`^7.4.2`, and the generated workspace currently emits 30 database tasks. Separate RC-tag facts from
+post-RC-main churn. Be comprehensive but write in one bounded synthesis turn. Do not edit any other
+file. End only after the report is complete.

.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/briefs/claude-opus-architecture-resume.md

@@ -0,0 +1,36 @@
+# Claude Opus 5 High — Resume Independent Architecture Synthesis
+
+Resume session `3f8a9a69-5589-4b91-9a32-91f7770fe7c2` in the same worktree and continue the
+already-started independent database architecture deep dive. You have already completed a broad
+Claude workflow/subagent fan-out and began the report, but the background parent paused immediately
+after creating its placeholder.
+
+Do not restart the research. Consume the specialist results already present in this session, resolve
+their disagreements, and finish the synthesis. You may resume or add focused Claude subagents only
+when a specific evidence gap genuinely remains. Stay Claude Opus 5 at high effort.
+
+Write exactly one substantive artifact:
+
+`.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/research/claude-opus-architecture-review.md`
+
+Replace the placeholder with the complete decision-grade report required by the original brief. It
+must include:
+
+- requested and observed model/provider/effort/session identity;
+- workflow/subagent roles and observable identifiers;
+- independent verdict and architectural thesis;
+- a complete target package/ownership graph and doctrine/archetype alignment;
+- target/config/schema-space/migration/runtime identity semantics;
+- concrete TypeScript API and DSL sketches;
+- plugin contribution and extensibility protocol;
+- control-plane command lifecycle, typed plan/apply/result/progress/error contracts, concurrency,
+  locking, recovery, and deterministic CI/offline behavior;
+- Prisma 8 adopt/wrap/reject/defer decisions and volatility containment;
+- provider matrix and multi-engine/multi-schema/multi-target behavior;
+- no-backward-compatibility migration/cutover plan with data safety and parallel-branch strategy;
+- conformance, generated-project, journey, negative-path, migration, and release gates;
+- risks, rejected alternatives, unresolved questions, and explicit decision checkpoints;
+- exact primary-source/local-source paths for load-bearing claims.
+
+Do not author or edit the canonical RFC, plan, worklog, supervisor, drift log, production code, or
+any other repository file. When the report is complete, end with a concise completion summary.

.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/briefs/claude-opus-architecture.md

@@ -0,0 +1,122 @@
+# Claude Code Opus 5 High — Independent Database Architecture Deep Dive
+
+## Role
+
+Use the NetScript harness. You are a subordinate architecture/research lane in an active RFC run,
+not the supervisor and not the formal PLAN-EVAL. Work independently from the Codex framing,
+challenge it, and return decision-grade evidence. You may use native Claude Workflows or focused
+Claude subagents when they materially improve coverage; if you do, record the workflow/subagent
+roles and observable identifiers in your report.
+
+Requested route: native Claude Code, Opus 5, effort high.
+
+## Worktree and run
+
+- Worktree: `/home/codex/repos/netscript-db-rfc`
+- Branch: `docs/database-architecture-rfc`
+- Run: `.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/`
+- Baseline: `origin/main@cd720529333328bcba5e1a308ce7632f4350efdf`
+- Prisma RC clone: `.llm/tmp/prisma-v8-rc1`
+- Prisma RC pin: `a76a6c5ad627ceaf1d78e874757cb2ca43e93ff5`
+- Prisma current-main pin observed by the supervisor: `71e2e0d9ee1f306b5a11435cd1973023cb33866a`
+
+Read `AGENTS.md` and the complete `.agents/skills/netscript-harness/SKILL.md` first. Follow its
+retrieval order for any doctrine/archetype decisions you make. This is a docs-only RFC research
+slice describing future Archetype 1/2/4/5/6 surfaces.
+
+## Owner intent
+
+This is a clean-break architectural redesign of NetScript's database story around Prisma 8 / Prisma
+Next. It is not a 1:1 Prisma migration. Backward compatibility must not constrain the design. Data
+migration safety and a mechanical migration path are required, but runtime compatibility facades,
+old generated clients, aliases, and hand-maintained shims are forbidden.
+
+The architecture must eliminate manual schema/type generation, generated-source patching, manual
+adapter assembly, Prisma-related CI instability, and copied plugin fragments while supporting
+multiple schemas, multiple databases (including two targets of the same provider), provider/runtime
+capability differences, plugin contributions, deterministic tooling, and an excellent human/CI/
+agent experience.
+
+## Required reading
+
+Read these completely before forming conclusions:
+
+- `.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/research/netscript-current-state.md`
+- `.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/research/prisma-8-deep-dive.md`
+- `.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/research/market-analysis.md`
+- `.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/plan.md`
+- `.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/context-pack.md`
+- `rfcs/PROCESS.md` and the RFC template it points to
+- relevant source paths cited by the current-state audit
+- Prisma RC source/scorecard/ADRs/control/runtime/skills in the local clone
+
+Do not accept the existing research's proposed conclusions merely because they are written. Verify
+load-bearing claims against source and flag any error, overreach, or missed alternative.
+
+## Independent questions
+
+1. What is the smallest durable NetScript database kernel, and what must remain Prisma-specific?
+2. Is a `DatabaseGraph` actually the right central abstraction? If so, define its identities,
+   invariants, compilation phases, and failure behavior. If not, propose a superior abstraction.
+3. What are the exact package boundaries and dependency directions? Assign the smallest fitting
+   NetScript archetype to each.
+4. Design implementation-grade TypeScript APIs for:
+   - application target definition and selection;
+   - runtime acquisition/scoping;
+   - schema/contract-space contributions;
+   - provider/driver/runtime adapters and capability negotiation;
+   - migration plan/apply/verify operations;
+   - validation artifact providers;
+   - testkit/conformance certification; and
+   - generated agent manifest/command context.
+5. How should same-provider multi-target, same-database multi-schema, cross-space relations,
+   replicas, serverless/request scope, and externally managed schemas differ in the type/domain
+   model?
+6. How should plugin upgrade, dependency ordering, collision, version skew, uninstall, retained
+   data, and external drift behave?
+7. Where can the design accidentally create a proprietary second ORM, an over-broad generic
+   repository, a service locator, or a lowest-common-denominator portability layer?
+8. Which Prisma 8 ideas should NetScript adopt, wrap, replace, or reject? Which exact upstream seams
+   are mature enough to integrate, and what must be gated?
+9. Design the zero-manual-step development loop and the deterministic CI/deployment protocol,
+   including atomic artifacts, stale-output detection, plan approval, cross-target partial failure,
+   resume, receipts, locks, and offline/Aspire classification.
+10. Design the clean-break migration and temporary parallel-branch strategy without reintroducing
+    compatibility into the product architecture.
+11. Produce a failure-mode analysis and an implementation/conformance test matrix that would catch
+    the incidents in the NetScript audit and the open Prisma 8 issues/PRs.
+12. Identify any decision that the RFC must leave conditional on Prisma 8 final rather than
+    pretending the RC has settled it.
+
+## Output contract
+
+Write exactly one file:
+
+`.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/research/claude-opus-architecture-review.md`
+
+Do not edit any other file. Do not commit, push, comment on GitHub, change labels, or author the
+canonical RFC.
+
+The report must contain:
+
+- requested and observed model/effort/session identity;
+- whether workflows/subagents were used and their roles/identifiers;
+- independent executive verdict;
+- corrected or missing research findings with evidence;
+- explicit architecture decision table with alternatives and rejection reasons;
+- package/dependency graph;
+- concrete API/DSL sketches (not merely nouns);
+- graph compilation/runtime/control lifecycle;
+- plugin contribution and removal protocol;
+- capability/ownership/error models;
+- multi-target transaction/failure semantics;
+- dev/CI/agent experience;
+- clean-break migration/parallel-branch strategy;
+- threat/failure-mode analysis;
+- implementation waves and per-wave proof gates;
+- unresolved decisions and upstream maturity gates;
+- severity-tagged adversarial findings against the current research/plan; and
+- a primary-source register.
+
+Distinguish observed fact, inference, and proposal. Prefer source and tests over stale prose. The
+result should be suitable for direct use by the supervisor when locking the Plan-Gate.

.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/briefs/claude-opus-report-part-1.md

@@ -0,0 +1,38 @@
+# Claude Opus 5 High — Architecture Report Part 1 of 3
+
+Resume the existing Opus architecture session. Do not reason from scratch, run commands, read more
+files, or invoke any agent/task/workflow. You already completed the evidence work and attempted one
+oversized final write that the transport interrupted before the tool envelope persisted.
+
+Use exactly one `Write` call to replace:
+
+`.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/research/claude-opus-architecture-review.md`
+
+Write a polished, self-contained first third (roughly 3,500–5,000 words; bounded enough to complete
+within this turn) containing:
+
+1. title, run/route identity, requested and observed Opus 5 high evidence, parent handle/session
+   chain, and a table of workflow/subagent roles/identifiers/statuses with truthful
+   incomplete/killed disclosures;
+2. independent verdict, architectural thesis, non-negotiable invariants, and what the redesign is
+   explicitly not;
+3. target package/ownership/dependency graph with one doctrine archetype per future package;
+4. complete identity model: target, connection/provisioning profile, namespace/schema, contribution
+   space, contract snapshot, migration lineage/head, runtime session, operation plan and receipt;
+5. concrete TypeScript public API sketches for the manifest/definition DSL, typed target refs,
+   composition factory, session/runtime access, generated app composition root, and contract-derived
+   Standard Schema input/output validation.
+
+Resolve rather than obscure the minimal-kernel tension: explain which data/protocol concepts are
+durable NetScript public contracts and which graph/factory/port machinery remains internal or
+consumer-owned. The owner-provided Prisma-maintainer exchange establishes a particularly important
+design hypothesis: the contract has enough runtime data to derive validation without another
+generation step. Treat this as primary exploratory evidence, not an upstream commitment. Make the
+default runtime-derived and contract-identity-cached; any AOT form is only an equivalent optional
+optimization. Do not make unsupported exact-count claims.
+
+End the file with exactly:
+
+`<!-- OPUS-CONTINUE-2 -->`
+
+Do not edit any other file. After the single Write succeeds, end the turn immediately.

.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/briefs/claude-opus-report-part-2.md

@@ -0,0 +1,42 @@
+# Claude Opus 5 High — Architecture Report Part 2 of 3
+
+Resume the same Opus architecture session. Do not run commands, read more files, or invoke any
+agent/task/workflow. Part 1 already exists and ends with `<!-- OPUS-CONTINUE-2 -->`.
+
+Use exactly one `Edit` call replacing that marker with a polished second third (roughly 3,500–5,000
+words) containing:
+
+6. contribution/plugin DSL and protocol: provenance, dependency ordering, capabilities,
+   ownership/conflict/augmentation, version skew, install/upgrade/removal/retention, migrations,
+   uninstall safety, conformance kit, upstream extension coexistence;
+7. control-plane operation lifecycle and concrete types for classify/compose/plan/apply/verify/
+   status/emit, consent, dotted errors, progress, receipts, locks, concurrency, expiry, resume,
+   partial multi-target success, artifact postconditions, offline determinism, CI cacheability, and
+   generated agent surface;
+8. Prisma 8 adopt/wrap/reject/defer table and volatility-containment boundary;
+9. provider/engine/runtime matrix, Postgres-first implementation, multi-target/multi-schema
+   semantics, external/unmanaged schemas, Deno/serverless constraints, and non-Postgres contingency;
+10. a first-class pure-TypeScript schema-authoring and end-to-end type-system subsystem based on
+    Prisma Next's architecture direction: exact upstream capability versus NetScript ownership;
+    schema-as-code composition/imports/namespaces; models, relations, constraints, indexes, native
+    types and defaults; plugin-owned augmentation and conflict policy; multi-schema/multi-target
+    boundaries; static inference versus stable runtime contract identity; deterministic migration
+    coupling; and propagation from schema to typed operations, validation, routes/RPC/forms/SSR,
+    generated projects, tooling and agents. Include concrete public API sketches and explicitly
+    assess whether NetScript should expose, wrap, or translate Prisma's TypeScript schema surface.
+11. a deep runtime-validation subsystem based on the owner/Prisma-maintainer exchange: Standard
+    Schema boundary; mutation/query input validation; selection/projection-aware output validation
+    at API/SSR/external-service trust boundaries; runtime versus wire representations; codecs;
+    plugin spaces; cache identity/invalidation; structured failures; Fresh/forms/RPC integration;
+    and semantic equivalence for any optional atomic AOT projection. Explicitly reject
+    mirror-validator codegen as the default.
+
+Correct known precision points: `^7.8.0` root ranges, 30 generated DB tasks, TypeScript 5.9 optional
+peer, 138 top-level `orm-postgres` export keys, and no fragile skill-count totals. Clearly separate
+RC tag from post-RC main.
+
+End the inserted text with exactly:
+
+`<!-- OPUS-CONTINUE-3 -->`
+
+Do not edit any other file. After the single Edit succeeds, end the turn immediately.

.llm/runs/docs-database-architecture-rfc--prisma-8-rfc/briefs/claude-opus-report-part-3.md

@@ -0,0 +1,25 @@
+# Claude Opus 5 High — Architecture Report Part 3 of 3
+
+Resume the same Opus architecture session. Do not run commands, read more files, or invoke any
+agent/task/workflow. Parts 1–2 already exist and end with `<!-- OPUS-CONTINUE-3 -->`.
+
+Use exactly one `Edit` call replacing that marker with the final polished third (roughly 3,500–5,000
+words) containing:
+
+12. clean-break migration/cutover strategy with no runtime compatibility, data preflight/safety,
+    mechanical migration tool/docs, rollback boundaries, parallel branch policy, and feature-parity
+    accounting. Before leaving the API architecture, add an explicit transfer analysis from
+    NetScript's existing oRPC extension/factory/composition pattern to Prisma's native
+    `defineContract` TypeScript schema builder: what should be reused to preserve native inference,
+    what must not become a wrapper/re-export, and what database-only ownership/migration/lifecycle
+    rules are additionally required;
+13. implementation waves with package-by-package dependencies and acceptance gates;
+14. exhaustive conformance matrix spanning type/plan/artifact/result/lifecycle, generated-project,
+    journey, negative paths, real PostgreSQL, multi-target, plugin lifecycle, migration failure,
+    deterministic/atomic emission, Deno/import purity, CI and publish/release gates;
+15. failure-mode/risk ledger, rejected alternatives, unresolved/conditional decisions, kill/switch
+    criteria, explicit decision checkpoints for plan lock, and implementation blockers;
+16. exact local/primary source register and a concise final recommendation.
+
+Finish cleanly with no continuation marker. Do not edit any other file. After the single Edit
+succeeds, end the turn immediately.