@@ -482,7 +482,7 @@ pub fn run(root: &Path) -> Result<()> {
         "tests/cli.rs",
         &[
             "cellc_rejects_registry_dependency_without_namespace",
-            "cellc_build_resolves_registry_dependency_and_writes_phase1_lockfile",
+            "cellc_build_resolves_artifact_api_dependency_and_writes_lockfile",
             "cellc_auth_namespace_claim_posts_signed_capability_payload_to_registry_api",
             "cellc_install_path_updates_lockfile_and_remove_prunes_it",
             "cellc_fmt_subcommand_formats_sources",
@@ -495,7 +495,7 @@ pub fn run(root: &Path) -> Result<()> {
         root,
         "tests/registry.rs",
         &[
-            "package_manager_resolves_registry_dependency_with_source_hash_from_local_git_fixture",
+            "package_manager_resolves_artifact_api_dependency_with_source_hash",
             "package_manager_persists_unverified_registry_policy_in_dependency_manifest",
             "package_manager_rejects_registry_source_hash_mismatch",
             "lockfile_consistency_accepts_matching_registry_source",
 
@@ -57,10 +57,12 @@ coverage.
 
 The `ci` gate also typechecks/tests `services/registry-api`, builds both Node
 entrypoints, performs its Wrangler dry-run build, and runs tests and clippy for
-the independent real-compiler Registry verifier crate. `dev` at least checks that
-verifier crate. This pins the publish contract, additive queue migration,
-worker boundary, and database/static-object shape to the compiler-generated
-registry entry. It is local service coverage, not evidence
+the independent real-compiler Registry verifier crate. `dev` at least checks
+that verifier crate. This pins the single `/v1/artifacts` contract, orthogonal
+verification/deployment/availability states, generic artifact bundles,
+mainnet deployment evidence, additive migrations, worker boundary, and
+database/static-object shape to the CLI-generated Registry entry. It is local
+service coverage, not evidence
 that Cloudflare, R2, Hyperdrive, Neon, DNS, or a production deployment works.
 The CLI coverage includes the explicit first-publish admission sequence:
 `cellc auth capability submit`, `cellc auth namespace claim`, then
 
@@ -709,15 +709,13 @@ token = { version = "0.3.0", namespace = "cellscript" }
 Running `cellc build` triggers dependency resolution:
 
 1. Read `Cell.toml` `[dependencies]` → find `token` with `namespace = "cellscript"`.
-2. Query `https://api.registry.cellscript.dev/v1/packages/cellscript/token` and
-   select the latest version whose public status is eligible for ordinary
-   resolution.
-3. Read the accepted source repository, tag, source hash, Edition, and
-   compatibility-profile identity from that public record.
-4. Clone the source repo at the accepted tag (e.g., `v0.3.2`).
-5. Read `registry.json` from the cloned repo and require its package/version,
-   tag, source hash, Edition, and profile hash to match the accepted record.
-6. Verify the checked-out source tree against `source_hash`.
+2. Query `https://api.registry.cellscript.dev/v1/artifacts/cellscript/token`.
+3. Require the `cellscript_source` profile and `dependency` consumption mode,
+   then select an eligible verified release.
+4. Download its immutable source snapshot from the static Registry origin.
+5. Verify the snapshot object identity, package coordinate, file hashes,
+   Edition, compatibility-profile identity, and whole-tree source hash.
+6. Materialize the verified source into the dependency cache.
 7. Parse the dependency's `Cell.toml` → resolve transitive dependencies.
 8. Write `Cell.lock` with resolved versions and git provenance.
 
@@ -967,7 +965,7 @@ source → build → deployment, all bound by cryptographic hashes in
      Public Registry API        Source Repository
      (accepted status)          (github.com/cellscript/amm_pool)
      ┌─────────────────┐       ┌──────────────────────────────────┐
-     │ /v1/packages/   │       │ Cell.toml                        │
+     │ /v1/artifacts/  │       │ Cell.toml                        │
      │ cellscript/     │──────►│ registry.json   ← offline mirror │
      │ amm_pool        │       │ src/                             │
      └─────────────────┘       │ Cell.lock       ← cellc build    │
 
@@ -117,8 +117,8 @@ to current branch-specific evidence or forward design:
 - `CELLSCRIPT_GRAMMAR_GOVERNANCE_RFC.md` and
   `CELLSCRIPT_SYNTAX_COMBO_AUDIT_METHODOLOGY.md` for 0.19 grammar/syntax
   governance scope
-- `CELLSCRIPT_REGISTRY_PHASE1.md` for the 0.19 package/deployment identity
-  registry closure and 0.20 handoff boundary
+- `CELLSCRIPT_REGISTRY_PHASE1.md` for the current artifact, verification,
+  deployment-evidence, and public API contract
 - `archive/0.20/CELLSCRIPT_0_20_ROADMAP.md` for generated TypeScript action builders,
   live-chain registry verification, stateful flow evidence, and the bounded
   CellFabric JSON bridge
 
@@ -284,7 +284,7 @@ Deployed Registry liveness and public read verification:
 
 ```bash
 curl --fail --silent --show-error https://api.registry.cellscript.dev/ready
-curl --fail --silent --show-error 'https://api.registry.cellscript.dev/v1/packages?limit=5'
+curl --fail --silent --show-error 'https://api.registry.cellscript.dev/v1/artifacts?limit=5'
 curl --fail --silent --show-error https://registry.cellscript.dev/health
 curl --fail --silent --show-error https://cellscript.dev/registry/ > /dev/null
 ```
 
@@ -92,8 +92,8 @@ If you already know what you need, jump directly:
 11. [Scoped Invariants and ProofPlan](Tutorial-11-Scoped-Invariants-and-ProofPlan.md):
    inspect 0.15 invariant trigger/scope/read metadata and understand
    metadata-only ProofPlan gaps.
-12. [Phase 1 Registry: End-to-End](Tutorial-12-Phase1-Registry-End-to-End.md):
-   follow the registry package flow from init through verification.
+12. [Registry Artifacts: End-to-End](Tutorial-12-Phase1-Registry-End-to-End.md):
+   publish and inspect CellScript and non-CellScript artifacts.
 13. [Agentic Loops and cellscript-mcp](Tutorial-13-Agentic-Loops-and-cellscript-mcp.md):
    drive the read-oriented compiler surface from an automated writer in a
    write -> check -> explain -> fix loop.