@run402/sdk 4.95.0 → 4.96.0

package/dist/node/{gitvault-publication.js → vault-publication.js}

@@ -1,5 +1,5 @@
 /**
- * gitvault — publication (protocol rev 41 §6 + §4.4–4.7 + §5A client side;
+ * vault — publication (protocol rev 41 §6 + §4.4–4.7 + §5A client side;
  * task 5.4).
  *
  * What lives here:
@@ -13,12 +13,12 @@
  *     next_cursor coupling, strictly-above-anchor, gapless across pages,
  *     truthful total), chain linkage (`CHAIN_BROKEN`), and the transition
  *     fail-closed rule (`UPGRADE_REQUIRED`);
- *   - {@link GitvaultTransport} — the control-plane + bucket operations the
+ *   - {@link VaultTransport} — the control-plane + bucket operations the
  *     vault needs (extends task 5.3's creation transport) — and
- *     {@link createGitvaultHttpTransport}, the `fetch`-backed implementation
+ *     {@link createVaultHttpTransport}, the `fetch`-backed implementation
  *     over the SDK kernel (upload sessions → presigned PUT with
  *     `If-None-Match: *` → finalize);
- *   - {@link GitvaultVault} — discover/verify to newest with the RESUMABLE
+ *   - {@link Vault} — discover/verify to newest with the RESUMABLE
  *     verification budget, materialize (decrypt ref_state + retention_roots →
  *     the materialized pin), push (pack_set or a checkpoint-bearing head when
  *     the delta exceeds the 64-receipt budget, upload with receipt-compare,
@@ -37,29 +37,29 @@ import { mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { LocalError, isRun402Error } from "../errors.js";
-import { fetchGitvaultObjectBytes } from "./gitvault-edge-fetch.js";
-import { openGitvaultDestinationBackend } from "./gitvault-mirror-backend.js";
-import { GITVAULT_FORMAT, GITVAULT_GENESIS_EPOCH, GITVAULT_GENESIS_GENERATION, GITVAULT_HEX16_RE, GITVAULT_OID40_RE, GITVAULT_SUITE, attemptKeyCommitment, bytesToHex, checkFreshEpochKeyAgainstPriorKeys, checkHPartition, computeRotationId, computeTargetPartitionDigest, deriveDigestKey, deriveObjectKey, ekFingerprint, vkFingerprint, GITVAULT_TERMINAL_LOSS_DOCTOR_TEXT, GITVAULT_TERMINAL_LOSS_STATEMENT, epochRotationKeyCommitment, formatGitvaultTimestamp, fromBase64url, hexToBytes, jcs, keyEnvelopeLedgerId, keyedCommitment, newGitvaultId, newHex32, nextEpoch, objectsetContent, openBindingPreimage, openEpochRotationForRecipient, openFrame, parseAddWriterKeyPayload, parseGitvaultStrict, parseRotateEpochPayload, pinManifestLedgerId, randomBytes, sealFrame, sealKeyEnvelope, sha256Hex, signGitvaultObject, storedBytes, storedBytesSha256, toBase64url, verifyGitvaultObject, } from "../namespaces/gitvault.crypto.js";
-import { GITVAULT_ZERO_SHA256_SENTINEL } from "../namespaces/gitvault.types.js";
-import { gitvaultCheckpointStaleness } from "../namespaces/gitvault.js";
-import { crossProfileGitvaultHint } from "./gitvault-profile-scan.js";
-import { applyAddWriterKey, applyWriterSetUpdate, buildAddWriterKeyActivationPayload, buildWriterDoorAddWriterKeyPayload, initialWriterState, resolveActiveWriter, resolveKnownWriter, validateAddWriterKeyPayload, validateWriterSetUpdate, writerKeyIdOf, } from "./gitvault-writer-state.js";
-import { GITVAULT_DEPLOY_REF, hardenedGit, hasObject, hasObjects, isAncestor } from "./gitvault-snapshot.js";
+import { fetchVaultObjectBytes } from "./vault-edge-fetch.js";
+import { openVaultDestinationBackend } from "./vault-mirror-backend.js";
+import { VAULT_FORMAT, VAULT_GENESIS_EPOCH, VAULT_GENESIS_GENERATION, VAULT_HEX16_RE, VAULT_OID40_RE, VAULT_SUITE, attemptKeyCommitment, bytesToHex, checkFreshEpochKeyAgainstPriorKeys, checkHPartition, computeRotationId, computeTargetPartitionDigest, deriveDigestKey, deriveObjectKey, ekFingerprint, vkFingerprint, VAULT_TERMINAL_LOSS_DOCTOR_TEXT, VAULT_TERMINAL_LOSS_STATEMENT, epochRotationKeyCommitment, formatVaultTimestamp, fromBase64url, hexToBytes, jcs, keyEnvelopeLedgerId, keyedCommitment, newVaultId, newHex32, nextEpoch, objectsetContent, openBindingPreimage, openEpochRotationForRecipient, openFrame, parseAddWriterKeyPayload, parseVaultStrict, parseRotateEpochPayload, pinManifestLedgerId, randomBytes, sealFrame, sealKeyEnvelope, sha256Hex, signVaultObject, storedBytes, storedBytesSha256, toBase64url, verifyVaultObject, } from "../namespaces/vault.crypto.js";
+import { VAULT_ZERO_SHA256_SENTINEL } from "../namespaces/vault.types.js";
+import { vaultCheckpointStaleness } from "../namespaces/repos.js";
+import { crossProfileVaultHint } from "./vault-profile-scan.js";
+import { applyAddWriterKey, applyWriterSetUpdate, buildAddWriterKeyActivationPayload, buildWriterDoorAddWriterKeyPayload, initialWriterState, resolveActiveWriter, resolveKnownWriter, validateAddWriterKeyPayload, validateWriterSetUpdate, writerKeyIdOf, } from "./vault-writer-state.js";
+import { VAULT_DEPLOY_REF, hardenedGit, hasObject, hasObjects, isAncestor } from "./vault-snapshot.js";
 // ─── Constants (constants.json) ──────────────────────────────────────────────
-export const GITVAULT_MAX_CANONICAL_REFS = 10_000;
-export const GITVAULT_MAX_REF_UPDATES_PER_TRANSACTION = 1_000;
-export const GITVAULT_MAX_RETENTION_ROOT_ENTRIES = 50_000;
-export const GITVAULT_MAX_REPAIR_ADDED_ROOTS = 10_000;
-export const GITVAULT_MAX_WAL_RECEIPTS_PER_HEAD = 64;
-export const GITVAULT_MAX_CHECKPOINT_PACKS = 4_096;
-export const GITVAULT_MAX_CHECKPOINT_TOTAL_STORED_BYTES = 858993459200n;
-export const GITVAULT_MULTI_OBJECT_PACK_TARGET_BYTES = 201_326_592;
-export const GITVAULT_MAX_REF_STATE_OBJECT_BYTES = 33_554_432;
-export const GITVAULT_MAX_HEADS_PER_LISTING_PAGE = 1_000;
-export const GITVAULT_VERIFICATION_BUDGET_HEADS = 100_000;
-export const GITVAULT_RETENTION_MIN_DAYS = 90;
+export const VAULT_MAX_CANONICAL_REFS = 10_000;
+export const VAULT_MAX_REF_UPDATES_PER_TRANSACTION = 1_000;
+export const VAULT_MAX_RETENTION_ROOT_ENTRIES = 50_000;
+export const VAULT_MAX_REPAIR_ADDED_ROOTS = 10_000;
+export const VAULT_MAX_WAL_RECEIPTS_PER_HEAD = 64;
+export const VAULT_MAX_CHECKPOINT_PACKS = 4_096;
+export const VAULT_MAX_CHECKPOINT_TOTAL_STORED_BYTES = 858993459200n;
+export const VAULT_MULTI_OBJECT_PACK_TARGET_BYTES = 201_326_592;
+export const VAULT_MAX_REF_STATE_OBJECT_BYTES = 33_554_432;
+export const VAULT_MAX_HEADS_PER_LISTING_PAGE = 1_000;
+export const VAULT_VERIFICATION_BUDGET_HEADS = 100_000;
+export const VAULT_RETENTION_MIN_DAYS = 90;
 /** Default admission-conflict retries before the push gives up (each retry re-verifies + re-applies to the winner). */
-export const GITVAULT_PUSH_CONFLICT_RETRIES = 5;
+export const VAULT_PUSH_CONFLICT_RETRIES = 5;
 const CANONICAL_REF_RE = /^(?!.*\.\.)(?!.*\/\/)(?!.*@\{)refs\/(heads|tags|run402)\/[^\u0000-\u0020\u007f~^:?*[\\]+$/;
 const BRANCH_REF_RE = /^(?!.*\.\.)(?!.*\/\/)(?!.*@\{)refs\/heads\/[^\u0000-\u0020\u007f~^:?*[\\]+$/;
 const CURSOR_RE = /^[A-Za-z0-9_-]{1,256}$/;
@@ -72,10 +72,10 @@ function fail(code, message, context, details, nextActions) {
  * Resolved once from this package's own `package.json` — mirrors
  * `node/index.ts`'s `readSdkPackageVersion`, duplicated locally rather than
  * imported to avoid a dependency edge from this file (imported by the
- * cross-runtime `namespaces/gitvault.ts` via a dynamic `import()`, task
+ * cross-runtime `namespaces/repos.ts` via a dynamic `import()`, task
  * 5.0's public crypto surface) back onto the Node CLI/SDK entry module.
  */
-const GITVAULT_SDK_PACKAGE_VERSION = (() => {
+const VAULT_SDK_PACKAGE_VERSION = (() => {
     try {
         const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
         return typeof pkg.version === "string" ? pkg.version : "0.0.0";
@@ -92,12 +92,12 @@ const GITVAULT_SDK_PACKAGE_VERSION = (() => {
  * authorization input; no wire grammar is promised for it (protocol-v0.md
  * §4.14, `rotate_epoch_payload.json`'s own field `$comment`).
  */
-export function gitvaultReaderEntrypoint(entrypoint) {
-    return `run402@${GITVAULT_SDK_PACKAGE_VERSION}/${entrypoint}`;
+export function vaultReaderEntrypoint(entrypoint) {
+    return `run402@${VAULT_SDK_PACKAGE_VERSION}/${entrypoint}`;
 }
 // ─── Generations ─────────────────────────────────────────────────────────────
 export function generationToBigInt(generation) {
-    if (!GITVAULT_HEX16_RE.test(generation))
+    if (!VAULT_HEX16_RE.test(generation))
         fail("CHAIN_BROKEN", `malformed generation: ${generation}`, "parsing generation");
     return BigInt(`0x${generation}`);
 }
@@ -119,8 +119,8 @@ export async function evaluateRefTransaction(current, transaction, options) {
     const updates = transaction.updates;
     if (!Array.isArray(updates) || updates.length === 0)
         fail("REF_TRANSACTION_INVALID", "a ref transaction needs at least one update", "evaluating ref transaction");
-    if (updates.length > GITVAULT_MAX_REF_UPDATES_PER_TRANSACTION) {
-        fail("REF_STATE_LIMIT_EXCEEDED", `${updates.length} updates exceed the ${GITVAULT_MAX_REF_UPDATES_PER_TRANSACTION}-update transaction bound`, "evaluating ref transaction", { updates: updates.length, bound: GITVAULT_MAX_REF_UPDATES_PER_TRANSACTION });
+    if (updates.length > VAULT_MAX_REF_UPDATES_PER_TRANSACTION) {
+        fail("REF_STATE_LIMIT_EXCEEDED", `${updates.length} updates exceed the ${VAULT_MAX_REF_UPDATES_PER_TRANSACTION}-update transaction bound`, "evaluating ref transaction", { updates: updates.length, bound: VAULT_MAX_REF_UPDATES_PER_TRANSACTION });
     }
     const seen = new Set();
     for (const u of updates) {
@@ -134,9 +134,9 @@ export async function evaluateRefTransaction(current, transaction, options) {
         if (u.ref.startsWith("refs/run402/") && (options.protocol_refs ?? "refuse") === "refuse") {
             fail("REFNAME_UNSUPPORTED", `${u.ref} is protocol-owned (refs/run402/*); user pushes to it are refused`, "evaluating ref transaction", { ref: u.ref });
         }
-        if (u.expected_old_oid !== null && !GITVAULT_OID40_RE.test(u.expected_old_oid))
+        if (u.expected_old_oid !== null && !VAULT_OID40_RE.test(u.expected_old_oid))
             fail("REF_TRANSACTION_INVALID", `expected_old_oid for ${u.ref} is not a 40-hex oid`, "evaluating ref transaction", { ref: u.ref });
-        if (u.new_oid !== null && !GITVAULT_OID40_RE.test(u.new_oid))
+        if (u.new_oid !== null && !VAULT_OID40_RE.test(u.new_oid))
             fail("REF_TRANSACTION_INVALID", `new_oid for ${u.ref} is not a 40-hex oid`, "evaluating ref transaction", { ref: u.ref });
         if (u.new_oid === null && u.expected_old_oid === null)
             fail("REF_TRANSACTION_INVALID", `${u.ref}: a delete requires expected_old_oid`, "evaluating ref transaction", { ref: u.ref });
@@ -178,7 +178,7 @@ export async function evaluateRefTransaction(current, transaction, options) {
     }
     if (failures.length > 0) {
         const nextActions = [{ action: "refetch, reapply the transaction to the winner's map, retry" }];
-        // The force-with-lease inversion (gitvault-force-spelling-and-pin-fold):
+        // The force-with-lease inversion (vault-force-spelling-and-pin-fold):
         // git's remote-helper protocol carries force only as a `+` refspec
         // prefix, which `--force-with-lease` never sets — the lease cannot cross
         // the helper boundary, so a rebased tip arrives as a NON-force update
@@ -200,15 +200,15 @@ export async function evaluateRefTransaction(current, transaction, options) {
 /** §6.5 bound: ≤ 10 000 canonical refs and the serialized map ≤ 32 MiB. */
 export function assertRefMapCardinality(refs) {
     const n = Object.keys(refs).length;
-    if (n > GITVAULT_MAX_CANONICAL_REFS)
-        fail("REF_STATE_LIMIT_EXCEEDED", `${n} canonical refs exceed the ${GITVAULT_MAX_CANONICAL_REFS} bound`, "checking ref-state cardinality", { refs: n });
-    if (jcs(refs).length > GITVAULT_MAX_REF_STATE_OBJECT_BYTES)
+    if (n > VAULT_MAX_CANONICAL_REFS)
+        fail("REF_STATE_LIMIT_EXCEEDED", `${n} canonical refs exceed the ${VAULT_MAX_CANONICAL_REFS} bound`, "checking ref-state cardinality", { refs: n });
+    if (jcs(refs).length > VAULT_MAX_REF_STATE_OBJECT_BYTES)
         fail("REF_STATE_LIMIT_EXCEEDED", "the serialized ref map exceeds 32 MiB", "checking ref-state cardinality");
 }
 /** The §4.4 deploy-ref move: force-with-lease `refs/run402/deploys/latest` → `oid` (creation when absent). */
 export function deployRefTransaction(current, oid) {
-    const old = current[GITVAULT_DEPLOY_REF] ?? null;
-    return { updates: [{ ref: GITVAULT_DEPLOY_REF, expected_old_oid: old, new_oid: oid, force: old !== null }] };
+    const old = current[VAULT_DEPLOY_REF] ?? null;
+    return { updates: [{ ref: VAULT_DEPLOY_REF, expected_old_oid: old, new_oid: oid, force: old !== null }] };
 }
 // ─── §4.5 Retention roots (pure) ─────────────────────────────────────────────
 /** `effective_admitted_at = max(prepared_at, storage creation time of the winning admission record)` (§4.10). */
@@ -216,7 +216,7 @@ export function effectiveAdmittedAt(preparedAt, recordStorageCreatedAt) {
     return Date.parse(preparedAt) >= Date.parse(recordStorageCreatedAt) ? preparedAt : recordStorageCreatedAt;
 }
 /** A root may be removed iff `effective_admitted_at + 90 days < cutoff_at` (STRICT; §4.5a). */
-export function isRootEligibleForRemoval(effectiveAdmittedAtIso, cutoffAtIso, retentionDays = GITVAULT_RETENTION_MIN_DAYS) {
+export function isRootEligibleForRemoval(effectiveAdmittedAtIso, cutoffAtIso, retentionDays = VAULT_RETENTION_MIN_DAYS) {
     const expiry = Date.parse(effectiveAdmittedAtIso) + retentionDays * 24 * 60 * 60 * 1000;
     return expiry < Date.parse(cutoffAtIso);
 }
@@ -243,14 +243,14 @@ export function evolveRetentionRoots(previous, options) {
         });
     }
     roots.sort(compareRoots);
-    if (roots.length > GITVAULT_MAX_RETENTION_ROOT_ENTRIES)
-        fail("REF_STATE_LIMIT_EXCEEDED", `${roots.length} retention roots exceed the ${GITVAULT_MAX_RETENTION_ROOT_ENTRIES} bound`, "evolving retention roots", { roots: roots.length });
+    if (roots.length > VAULT_MAX_RETENTION_ROOT_ENTRIES)
+        fail("REF_STATE_LIMIT_EXCEEDED", `${roots.length} retention roots exceed the ${VAULT_MAX_RETENTION_ROOT_ENTRIES} bound`, "evolving retention roots", { roots: roots.length });
     return roots;
 }
 // ─── clone-installs-retained-refs (D1-D5): local refs/r402/retain/* bookkeeping ──
 /**
  * The client-local, protocol-owned namespace (design D4). Distinct from the
- * VAULT-side `refs/run402/*` (e.g. `GITVAULT_DEPLOY_REF`) that rides the wire
+ * VAULT-side `refs/run402/*` (e.g. `VAULT_DEPLOY_REF`) that rides the wire
  * as part of `ref_state` — `refs/r402/*` never rides the wire at all; it is
  * written directly into the local `.git` by the materializer and reconciled
  * on every later fetch/fsck. A push naming any ref under it is refused by the
@@ -258,14 +258,14 @@ export function evolveRetentionRoots(previous, options) {
  * `git-remote-run402.mjs`'s `partitionProtectedRefPushes`) — this constant is
  * the ONE place the namespace string is spelled, shared by both sides.
  */
-export const GITVAULT_R402_REF_NAMESPACE = "refs/r402/";
+export const VAULT_R402_REF_NAMESPACE = "refs/r402/";
 /** Where a retained (branch-unreachable) deploy-capture tip gets its local ref (design D1/D2). */
-export const GITVAULT_RETAIN_REF_PREFIX = `${GITVAULT_R402_REF_NAMESPACE}retain/`;
+export const VAULT_RETAIN_REF_PREFIX = `${VAULT_R402_REF_NAMESPACE}retain/`;
 /**
  * D1's ref-identity choice, recorded here because the design doc's own
- * assumption did not hold: `GitvaultRetentionRoot` carries no per-capture
+ * assumption did not hold: `VaultRetentionRoot` carries no per-capture
  * stable id (only `{ref, oid, dropped_at_generation}`) — the capture id that
- * DOES exist (`GitvaultHead.capture_binding.capture_id`) lives on the head
+ * DOES exist (`VaultHead.capture_binding.capture_id`) lives on the head
  * that INTRODUCED a tip onto a canonical ref, not on the retention-root entry
  * recording its later displacement, and correlating the two would require
  * walking the chain further back than materialization already reads (D2
@@ -274,8 +274,8 @@ export const GITVAULT_RETAIN_REF_PREFIX = `${GITVAULT_R402_REF_NAMESPACE}retain/
  * ever changes for the same history), and needs no correlation at all — the
  * ref name IS the tip's own identity.
  */
-export function gitvaultRetainedRefName(oid) {
-    return `${GITVAULT_RETAIN_REF_PREFIX}${oid}`;
+export function vaultRetainedRefName(oid) {
+    return `${VAULT_RETAIN_REF_PREFIX}${oid}`;
 }
 /** `git for-each-ref --format='%(objectname) %(refname)' <prefix>` → `Map<refname, oid>`. Namespace-scoped by construction (the prefix argv). */
 async function listRefsUnderPrefix(repoDir, prefix) {
@@ -316,14 +316,14 @@ async function listRefsUnderPrefix(repoDir, prefix) {
  * never a warning.
  */
 /**
- * Name prefix of the scratch directory {@link GitvaultVault.buildPacks}
+ * Name prefix of the scratch directory {@link Vault.buildPacks}
  * allocates INSIDE the repository's git common dir. Dotted and clearly named
  * so it can never be mistaken for `objects/`, `refs/`, or a pack directory.
  */
-export const GITVAULT_PACK_SCRATCH_PREFIX = ".run402-gitvault-packs-";
+export const VAULT_PACK_SCRATCH_PREFIX = ".run402-vault-packs-";
 /**
  * Allocate the pack-objects scratch directory on the OBJECT STORE's own
- * filesystem: `<git-common-dir>/.run402-gitvault-packs-XXXXXX`, never under
+ * filesystem: `<git-common-dir>/.run402-vault-packs-XXXXXX`, never under
  * `os.tmpdir()`.
  *
  * `git pack-objects <base>` writes its temporary pack under
@@ -338,7 +338,7 @@ export const GITVAULT_PACK_SCRATCH_PREFIX = ".run402-gitvault-packs-";
  */
 export async function allocatePackScratchDir(repoDir) {
     const commonDir = (await hardenedGit(repoDir, ["rev-parse", "--path-format=absolute", "--git-common-dir"])).text().trim();
-    return mkdtempSync(join(commonDir, GITVAULT_PACK_SCRATCH_PREFIX));
+    return mkdtempSync(join(commonDir, VAULT_PACK_SCRATCH_PREFIX));
 }
 export async function reconcileRetainedTipRefs(repoDir, state) {
     const empty = (warning = null) => ({ written: [], deleted: [], retained_count: 0, warning });
@@ -386,8 +386,8 @@ export async function reconcileRetainedTipRefs(repoDir, state) {
             if (!reachable)
                 retainedOids.push(oid);
         }
-        const existing = await listRefsUnderPrefix(repoDir, GITVAULT_RETAIN_REF_PREFIX);
-        const desired = new Map(retainedOids.map((oid) => [gitvaultRetainedRefName(oid), oid]));
+        const existing = await listRefsUnderPrefix(repoDir, VAULT_RETAIN_REF_PREFIX);
+        const desired = new Map(retainedOids.map((oid) => [vaultRetainedRefName(oid), oid]));
         const toWrite = [];
         for (const [ref, oid] of desired)
             if (existing.get(ref) !== oid)
@@ -414,40 +414,40 @@ export async function reconcileRetainedTipRefs(repoDir, state) {
 }
 /** Validate a listing request before it is sent (the request schema, D186). */
 export function validateHeadsListingRequest(request) {
-    if (!GITVAULT_HEX16_RE.test(request.after_generation))
-        fail("GITVAULT_LISTING_REQUEST_INVALID", "after_generation is REQUIRED and must be 16 lowercase hex (the verification anchor)", "listing heads", { after_generation: request.after_generation });
+    if (!VAULT_HEX16_RE.test(request.after_generation))
+        fail("VAULT_LISTING_REQUEST_INVALID", "after_generation is REQUIRED and must be 16 lowercase hex (the verification anchor)", "listing heads", { after_generation: request.after_generation });
     if (!LIMIT_RE.test(request.limit))
-        fail("GITVAULT_LISTING_REQUEST_INVALID", "limit is REQUIRED and must be 1..1000", "listing heads", { limit: request.limit });
+        fail("VAULT_LISTING_REQUEST_INVALID", "limit is REQUIRED and must be 1..1000", "listing heads", { limit: request.limit });
     if (request.cursor !== undefined && !CURSOR_RE.test(request.cursor))
         fail("INVALID_CURSOR", "cursor violates the opaque-token grammar; restart from after_generation without a cursor and echo each page's next_cursor unchanged", "listing heads", { cursor: request.cursor });
 }
 /**
  * Validate one page against the request and the sequence so far. Returns the
  * advanced progress. Refusals: anchor not echoed / wrong vault / coupling
- * violation / retired member → `GITVAULT_LISTING_PAGE_INVALID`; an entry at or
+ * violation / retired member → `VAULT_LISTING_PAGE_INVALID`; an entry at or
  * below the anchor → `GENERATION_REGRESSION`; a gap within or across pages →
  * `CHAIN_BROKEN`; an untruthful final `total` → `CHAIN_BROKEN`.
  */
 export function verifyHeadsListingPage(page, request, progress, expectedRepoId) {
     const p = page;
-    if (p.format !== GITVAULT_FORMAT)
-        fail("GITVAULT_LISTING_PAGE_INVALID", "listing page has the wrong format", "listing heads");
+    if (p.format !== VAULT_FORMAT)
+        fail("VAULT_LISTING_PAGE_INVALID", "listing page has the wrong format", "listing heads");
     if ("next_after_generation" in p)
-        fail("GITVAULT_LISTING_PAGE_INVALID", "listing page carries the retired next_after_generation member (D186 forbids it)", "listing heads");
+        fail("VAULT_LISTING_PAGE_INVALID", "listing page carries the retired next_after_generation member (D186 forbids it)", "listing heads");
     if (expectedRepoId && p.repo_id !== expectedRepoId)
-        fail("GITVAULT_LISTING_PAGE_INVALID", "listing page is for a different vault", "listing heads", { repo_id: p.repo_id });
+        fail("VAULT_LISTING_PAGE_INVALID", "listing page is for a different vault", "listing heads", { repo_id: p.repo_id });
     if (p.after_generation !== request.after_generation || p.after_generation !== progress.after_generation)
-        fail("GITVAULT_LISTING_PAGE_INVALID", "the page did not echo the request's after_generation anchor", "listing heads", { echoed: p.after_generation, anchor: request.after_generation });
+        fail("VAULT_LISTING_PAGE_INVALID", "the page did not echo the request's after_generation anchor", "listing heads", { echoed: p.after_generation, anchor: request.after_generation });
     if (typeof p.has_more !== "boolean")
-        fail("GITVAULT_LISTING_PAGE_INVALID", "has_more must be a boolean", "listing heads");
+        fail("VAULT_LISTING_PAGE_INVALID", "has_more must be a boolean", "listing heads");
     if (p.has_more === false && p.next_cursor !== null)
-        fail("GITVAULT_LISTING_PAGE_INVALID", "has_more=false with a non-null next_cursor is contradictory", "listing heads");
+        fail("VAULT_LISTING_PAGE_INVALID", "has_more=false with a non-null next_cursor is contradictory", "listing heads");
     if (p.has_more === true && (typeof p.next_cursor !== "string" || !CURSOR_RE.test(p.next_cursor)))
-        fail("GITVAULT_LISTING_PAGE_INVALID", "has_more=true requires a non-null opaque next_cursor", "listing heads");
-    if (!Array.isArray(p.heads) || p.heads.length > GITVAULT_MAX_HEADS_PER_LISTING_PAGE || p.heads.length > Number(request.limit))
-        fail("GITVAULT_LISTING_PAGE_INVALID", "heads[] exceeds the page limit", "listing heads");
+        fail("VAULT_LISTING_PAGE_INVALID", "has_more=true requires a non-null opaque next_cursor", "listing heads");
+    if (!Array.isArray(p.heads) || p.heads.length > VAULT_MAX_HEADS_PER_LISTING_PAGE || p.heads.length > Number(request.limit))
+        fail("VAULT_LISTING_PAGE_INVALID", "heads[] exceeds the page limit", "listing heads");
     if (p.total !== null && !/^(0|[1-9][0-9]{0,14})$/.test(p.total))
-        fail("GITVAULT_LISTING_PAGE_INVALID", "total must be an exact decimal string or null", "listing heads");
+        fail("VAULT_LISTING_PAGE_INVALID", "total must be an exact decimal string or null", "listing heads");
     let last = generationToBigInt(progress.last_generation);
     const anchor = generationToBigInt(progress.after_generation);
     let delivered = progress.delivered;
@@ -477,7 +477,7 @@ export function nextListingRequest(request, page) {
     if (!page.has_more)
         return null;
     if (page.next_cursor === null)
-        fail("GITVAULT_LISTING_PAGE_INVALID", "has_more=true requires a non-null opaque next_cursor", "listing heads");
+        fail("VAULT_LISTING_PAGE_INVALID", "has_more=true requires a non-null opaque next_cursor", "listing heads");
     return { after_generation: request.after_generation, cursor: page.next_cursor, limit: request.limit };
 }
 /**
@@ -487,7 +487,7 @@ export function nextListingRequest(request, page) {
  */
 export function checkGenerationRegression(listedNewestGeneration, pinnedGeneration) {
     if (generationToBigInt(listedNewestGeneration) < generationToBigInt(pinnedGeneration)) {
-        fail("GENERATION_REGRESSION", `the vault's newest generation ${listedNewestGeneration} is below the authenticated pin ${pinnedGeneration}; refusing to publish over a rollback`, "verifying gitvault chain", { listed_newest_generation: listedNewestGeneration, pinned_generation: pinnedGeneration }, [{ action: "do not publish; escalate — the vault regressed below a generation this client authenticated" }]);
+        fail("GENERATION_REGRESSION", `the vault's newest generation ${listedNewestGeneration} is below the authenticated pin ${pinnedGeneration}; refusing to publish over a rollback`, "verifying vault chain", { listed_newest_generation: listedNewestGeneration, pinned_generation: pinnedGeneration }, [{ action: "do not publish; escalate — the vault regressed below a generation this client authenticated" }]);
     }
 }
 /** `SHA-256("r402s/v0/open-binding" ‖ lp(client_open_id) ‖ lp(base_head) ‖ lp_opt(prior) ‖ lp(cap))`. */
@@ -498,7 +498,7 @@ export function openBindingDigest(clientOpenId, record) {
  * Recompute the binding from the record's OWN fields and compare it bytewise
  * with the signed issuance digest. The error registry has no dedicated code for
  * the fence inequality (D145), so the client surfaces
- * `GITVAULT_OPEN_BINDING_MISMATCH`; a same-`client_open_id` retry that carries a
+ * `VAULT_OPEN_BINDING_MISMATCH`; a same-`client_open_id` retry that carries a
  * DIFFERENT binding is the registry's `CLIENT_OPEN_ID_CONFLICT`.
  */
 export function checkOpenBinding(clientOpenId, record, issuanceOpenBindingSha256, options = {}) {
@@ -508,7 +508,7 @@ export function checkOpenBinding(clientOpenId, record, issuanceOpenBindingSha256
     if (options.retry) {
         fail("CLIENT_OPEN_ID_CONFLICT", `client_open_id ${clientOpenId} was already opened with a different request binding`, "checking maintenance open binding", { recomputed, issued: issuanceOpenBindingSha256 });
     }
-    fail("GITVAULT_OPEN_BINDING_MISMATCH", `the C1 record does not recompute to the signed issuance binding for ${clientOpenId}`, "checking maintenance open binding", { recomputed, issued: issuanceOpenBindingSha256 });
+    fail("VAULT_OPEN_BINDING_MISMATCH", `the C1 record does not recompute to the signed issuance binding for ${clientOpenId}`, "checking maintenance open binding", { recomputed, issued: issuanceOpenBindingSha256 });
 }
 /** Verify one link: bytes hash to the listing, strict parse, generation, prev linkage, epoch pin, repo, writer signature. */
 export function checkChainLink(input) {
@@ -516,7 +516,7 @@ export function checkChainLink(input) {
     const hash = sha256Hex(input.stored_bytes);
     if (hash !== input.listed_sha256)
         fail("CHAIN_BROKEN", `head ${input.expected_generation}: stored bytes hash ${hash} ≠ the listing's ${input.listed_sha256}`, "verifying head chain", { generation: input.expected_generation });
-    if (h.format !== GITVAULT_FORMAT || h.object_kind !== "head" || h.suite !== GITVAULT_SUITE)
+    if (h.format !== VAULT_FORMAT || h.object_kind !== "head" || h.suite !== VAULT_SUITE)
         fail("CHAIN_BROKEN", `head ${input.expected_generation}: not an r402s/v0 head`, "verifying head chain");
     if (h.repo_id !== input.repo_id)
         fail("CHAIN_BROKEN", `head ${input.expected_generation}: repo_id ${h.repo_id} ≠ ${input.repo_id}`, "verifying head chain");
@@ -530,7 +530,7 @@ export function checkChainLink(input) {
     // exactly (increment-by-one, no skip). Pure and keyless: this checks only
     // the head's own signed `epoch` FIELD against the predecessor's, never
     // opens any envelope — decrypting under the resulting epoch is a separate,
-    // keyed step (`GitvaultVault`'s rotation-envelope open, `openEpochRotationForRecipient`).
+    // keyed step (`Vault`'s rotation-envelope open, `openEpochRotationForRecipient`).
     const isRotation = h.transition !== null && h.transition.kind === "rotate_epoch";
     const permittedEpoch = isRotation ? nextEpoch(input.prev_epoch) : input.prev_epoch;
     if (h.epoch !== permittedEpoch) {
@@ -538,7 +538,7 @@ export function checkChainLink(input) {
     }
     if (h.writer_key_id !== input.writer_key_id)
         fail("CHAIN_BROKEN", `head ${h.generation}: writer_key_id ${h.writer_key_id} is not the registered writer`, "verifying head chain");
-    if (!verifyGitvaultObject(h, input.writer_public_key))
+    if (!verifyVaultObject(h, input.writer_public_key))
         fail("CHAIN_BROKEN", `head ${h.generation}: signature does not verify under the registered writer key`, "verifying head chain");
     if ((h.checkpoint === null) !== (h.checkpoint_purpose === null))
         fail("CHAIN_BROKEN", `head ${h.generation}: checkpoint/checkpoint_purpose must be null together`, "verifying head chain");
@@ -546,7 +546,7 @@ export function checkChainLink(input) {
         fail("CHAIN_BROKEN", `head ${h.generation}: a checkpoint-bearing head must carry an empty WAL set`, "verifying head chain");
     if ((h.repair !== null) !== (h.checkpoint_purpose === "repair"))
         fail("CHAIN_BROKEN", `head ${h.generation}: repair ⇔ checkpoint_purpose "repair"`, "verifying head chain");
-    if (h.wal_entries.length > GITVAULT_MAX_WAL_RECEIPTS_PER_HEAD)
+    if (h.wal_entries.length > VAULT_MAX_WAL_RECEIPTS_PER_HEAD)
         fail("CHAIN_BROKEN", `head ${h.generation}: ${h.wal_entries.length} WAL receipts exceed the 64 budget`, "verifying head chain");
 }
 /**
@@ -559,10 +559,10 @@ export function checkChainLink(input) {
  * rotation is ACTIVATED") — `checkChainLink`'s own D194 epoch-continuity
  * check already validates its structural admissibility, and
  * {@link parseRotateEpochPayload} / the caller's own envelope-open step
- * (`GitvaultVault.verifyToNewest`) handle it fully. `add_writer_key` is
- * EXEMPT as of rev 47 (gitvault-multi-writer) the same way — {@link
+ * (`Vault.verifyToNewest`) handle it fully. `add_writer_key` is
+ * EXEMPT as of rev 47 (vault-multi-writer) the same way — {@link
  * parseAddWriterKeyPayload} + `validateAddWriterKeyPayload`
- * (`gitvault-writer-state.js`) handle it fully, INSIDE `verifyToNewest`'s
+ * (`vault-writer-state.js`) handle it fully, INSIDE `verifyToNewest`'s
  * own loop, BEFORE this function ever runs on that head (so a transition
  * that fails writer validation never reaches here at all — this function
  * only ever sees ones that already passed). The other two kinds
@@ -599,7 +599,7 @@ const PATH_PATTERNS = [
     [/^verifier-receipts\/(vr_[0-9a-f]{32})\.json$/, (m) => ({ kind: "object", read: { object_kind: "verifier_receipt", object_id: m[1] } })],
 ];
 /** `null` for a path with no wire identity (e.g. a locally-held cutoff ticket). */
-export function gitvaultWireRefForPath(path) {
+export function vaultWireRefForPath(path) {
     for (const [re, build] of PATH_PATTERNS) {
         const m = re.exec(path);
         if (m)
@@ -608,24 +608,24 @@ export function gitvaultWireRefForPath(path) {
     return null;
 }
 /** The manifest entry for one upload — closed-key, exactly what the control plane validates. */
-export function gitvaultManifestEntry(object) {
-    const ref = gitvaultWireRefForPath(object.path);
+export function vaultManifestEntry(object) {
+    const ref = vaultWireRefForPath(object.path);
     if (!ref || ref.kind !== "object") {
-        fail("GITVAULT_UPLOAD_SESSION_INVALID", `${object.path} is not an uploadable object path; the control plane addresses uploads by object_kind + ledger identity`, "building the gitvault upload manifest", { path: object.path });
+        fail("VAULT_UPLOAD_SESSION_INVALID", `${object.path} is not an uploadable object path; the control plane addresses uploads by object_kind + ledger identity`, "building the vault upload manifest", { path: object.path });
     }
     const entry = { ...ref.read, sha256: object.sha256, size_bytes: object.size_bytes };
     if (entry.object_kind === "wal_pack") {
         if (object.base_generation === undefined)
-            fail("GITVAULT_UPLOAD_SESSION_INVALID", "a wal_pack upload must declare base_generation (§4.1)", "building the gitvault upload manifest", { path: object.path });
+            fail("VAULT_UPLOAD_SESSION_INVALID", "a wal_pack upload must declare base_generation (§4.1)", "building the vault upload manifest", { path: object.path });
         entry.base_generation = object.base_generation;
     }
     return entry;
 }
-// ─── Inline upload (gitvault-composite-state-read design D2) ─────────────────
-/** Mirrors the gateway's `GITVAULT_INLINE_UPLOAD_MAX_OBJECT_BYTES` (`services/gitvault/upload-sessions.ts`). */
-export const GITVAULT_INLINE_UPLOAD_MAX_OBJECT_BYTES = 262_144;
-/** Mirrors the gateway's `GITVAULT_INLINE_UPLOAD_MAX_REQUEST_BYTES`. */
-export const GITVAULT_INLINE_UPLOAD_MAX_REQUEST_BYTES = 1_048_576;
+// ─── Inline upload (vault-composite-state-read design D2) ─────────────────
+/** Mirrors the gateway's `VAULT_INLINE_UPLOAD_MAX_OBJECT_BYTES` (`services/vault/upload-sessions.ts`). */
+export const VAULT_INLINE_UPLOAD_MAX_OBJECT_BYTES = 262_144;
+/** Mirrors the gateway's `VAULT_INLINE_UPLOAD_MAX_REQUEST_BYTES`. */
+export const VAULT_INLINE_UPLOAD_MAX_REQUEST_BYTES = 1_048_576;
 /**
  * The client-side mirror of the gateway's `isInlineUploadRequest` + per-object/
  * per-request cap check: every object must fit under the PER-OBJECT cap AND
@@ -636,30 +636,30 @@ export const GITVAULT_INLINE_UPLOAD_MAX_REQUEST_BYTES = 1_048_576;
  * already short-circuits before this is consulted, and `putObject` always
  * wraps exactly one object so it never hits this branch).
  *
- * Takes the narrowest shape that satisfies every call site (`GitvaultUploadObject[]`
+ * Takes the narrowest shape that satisfies every call site (`VaultUploadObject[]`
  * for `uploadObjects`, a single `{bytes}`-shaped array for `putObject`) so
  * neither caller needs to fabricate unrelated fields just to ask the
  * question.
  */
-export function gitvaultInlineUploadEligible(objects) {
+export function vaultInlineUploadEligible(objects) {
     if (objects.length === 0)
         return false;
     let total = 0;
     for (const o of objects) {
-        if (o.bytes.length > GITVAULT_INLINE_UPLOAD_MAX_OBJECT_BYTES)
+        if (o.bytes.length > VAULT_INLINE_UPLOAD_MAX_OBJECT_BYTES)
             return false;
         total += o.bytes.length;
     }
-    return total <= GITVAULT_INLINE_UPLOAD_MAX_REQUEST_BYTES;
+    return total <= VAULT_INLINE_UPLOAD_MAX_REQUEST_BYTES;
 }
 /**
  * The stable key both sides agree on, used to pair receipts back to
  * requests — MIRRORS the gateway's `keyEnvelopeLedgerId`/`pinManifestLedgerId`
- * (services/gitvault/epoch-rotation.ts) exactly; drift here breaks receipt
+ * (services/vault/epoch-rotation.ts) exactly; drift here breaks receipt
  * pairing at upload finalize for a rotation-attempt envelope or a pin
  * manifest.
  */
-export function gitvaultLedgerId(read) {
+export function vaultLedgerId(read) {
     if (read.object_kind === "key_envelope")
         return keyEnvelopeLedgerId(read.epoch, read.recipient_fingerprint, read.rotation_id ?? null);
     if (read.object_kind === "recipient_pin_manifest")
@@ -670,12 +670,12 @@ export function gitvaultLedgerId(read) {
  * `scheme://host` for a URL string, or `null` for anything that fails to
  * parse (never thrown) — the sole normalizer between a full presigned/edge
  * URL (path, query, signature, everything) and the bare origin
- * {@link GitvaultHttpTransportOptions.onObjectStoreOriginObserved} hands a
+ * {@link VaultHttpTransportOptions.onObjectStoreOriginObserved} hands a
  * caller. Deliberately NOT exported: this module is the only place that
  * observes raw object-store URLs, so the normalizer has exactly one call
  * site and needs no wider audience.
  */
-function gitvaultObjectStoreOrigin(url) {
+function vaultObjectStoreOrigin(url) {
     try {
         return new URL(url).origin;
     }
@@ -684,12 +684,12 @@ function gitvaultObjectStoreOrigin(url) {
     }
 }
 /** Dedup, in order, dropping anything that failed to parse. */
-function gitvaultObjectStoreOrigins(urls) {
+function vaultObjectStoreOrigins(urls) {
     const out = [];
     for (const u of urls) {
         if (!u)
             continue;
-        const origin = gitvaultObjectStoreOrigin(u);
+        const origin = vaultObjectStoreOrigin(u);
         if (origin && !out.includes(origin))
             out.push(origin);
     }
@@ -698,13 +698,13 @@ function gitvaultObjectStoreOrigins(urls) {
 function b64(bytes) { return Buffer.from(bytes).toString("base64"); }
 function b64u(bytes) { return Buffer.from(bytes).toString("base64url"); }
 /**
- * Independent reads/PUTs within one gitvault step run at this concurrency
+ * Independent reads/PUTs within one vault step run at this concurrency
  * (design D2) — "browser-era origin etiquette", well within what S3/the
  * gateway tolerate, and it keeps in-flight memory bounded by ~6×frame size.
  * Chain-ordered steps (the head-chain walk, admission, readback) never call
  * this — they stay strictly sequential.
  */
-export const GITVAULT_TRANSPORT_CONCURRENCY = 6;
+export const VAULT_TRANSPORT_CONCURRENCY = 6;
 /**
  * Run `fn` over `items` with at most `limit` in flight at once, preserving
  * result order regardless of completion order. A plain worker-pool: `limit`
@@ -729,9 +729,9 @@ export async function mapBounded(items, limit, fn) {
  * `If-None-Match: *` (create-only — the bucket policy demands it) and the
  * FULL_OBJECT SHA-256 checksum header.
  */
-export function createGitvaultHttpTransport(client, options = {}) {
+export function createVaultHttpTransport(client, options = {}) {
     const vid = (repoId) => encodeURIComponent((options.vaultIdFor ?? ((r) => r))(repoId));
-    const base = (repoId) => `/gitvault/v1/vaults/${vid(repoId)}`;
+    const base = (repoId) => `/vaults/v1/${vid(repoId)}`;
     /**
      * Read raw bytes from a generation-addressed route (heads, admission records).
      *
@@ -743,15 +743,15 @@ export function createGitvaultHttpTransport(client, options = {}) {
      */
     async function getGenerationBytes(repoId, route, generation) {
         const path = `${base(repoId)}/${route}/${encodeURIComponent(generation)}`;
-        const auth = (await client.credentials.getAuth(path, { method: `gitvault.read_${route}` })) ?? {};
+        const auth = (await client.credentials.getAuth(path, { method: `vault.read_${route}` })) ?? {};
         const r = await client.fetch(`${client.apiBase}${path}`, { method: "GET", headers: { ...auth, accept: "application/json" } });
         if (r.status === 404)
             return null;
         if (!r.ok) {
             // Surface the registry code the control plane actually sent (e.g.
-            // `GITVAULT_ACCESS_DENIED`) rather than flattening every refusal into a
+            // `VAULT_ACCESS_DENIED`) rather than flattening every refusal into a
             // generic read failure — the codes carry the caller's next action.
-            let code = "GITVAULT_OBJECT_READ_FAILED";
+            let code = "VAULT_OBJECT_READ_FAILED";
             let message = `${route}/${generation} read failed (HTTP ${r.status})`;
             try {
                 const envelope = (await r.json());
@@ -763,12 +763,12 @@ export function createGitvaultHttpTransport(client, options = {}) {
             catch {
                 // a non-JSON body — keep the generic code
             }
-            fail(code, message, `reading gitvault ${route}`, { generation, status: r.status });
+            fail(code, message, `reading vault ${route}`, { generation, status: r.status });
         }
         return new Uint8Array(await r.arrayBuffer());
     }
     /**
-     * Resolve ONE `object-reads` presign target to bytes (gitvault-small-
+     * Resolve ONE `object-reads` presign target to bytes (vault-small-
      * object-inline design D3): consume `inline` when present and EITHER no
      * `expectedSha256` was supplied OR the decoded bytes hash to it, else
      * fall through to the ordinary `url`/`edge_url` fetch exactly as before
@@ -780,23 +780,23 @@ export function createGitvaultHttpTransport(client, options = {}) {
      * authorized caller, the entry's own `url` would have served — nothing
      * here becomes a new source of truth (design D5).
      *
-     * gitvault-object-host-predial (task 1.2): once the fetch below
+     * vault-object-host-predial (task 1.2): once the fetch below
      * COMPLETES (any status — a thrown fetch error is NOT this), reports the
      * target's origin(s) via `options.onObjectStoreOriginObserved`. Never
      * fired for the `inline` short-circuit above — no URL was dialed.
      */
     /**
-     * gitvault-byo-primary-bucket: a payload object of a BYO vault, named by
+     * vault-byo-primary-bucket: a payload object of a BYO vault, named by
      * the key the gateway handed back. Read from the vault's locally configured
      * destination — never from run402, which holds no copy. `null` when the
      * key is absent there (the caller's absence adjudication takes over,
-     * `GITVAULT_BYO_OBJECT_MISSING`); a machine with no local BYO config for
+     * `VAULT_BYO_OBJECT_MISSING`); a machine with no local BYO config for
      * the vault refuses by name instead of reporting a false absence.
      */
     async function readByoObject(repoId, key, what) {
         const backend = options.byoBackend?.(repoId) ?? null;
         if (!backend) {
-            fail("GITVAULT_BYO_NOT_CONFIGURED", `vault ${repoId} keeps its payload in its own bucket and this machine has no local BYO config for it — ${what} cannot be read`, "reading gitvault object", { repo_id: repoId, key }, [{ action: "this vault was allocated with `run402 repos create --byo <destination> --profile <name>|--ambient`; this machine needs the same destination and a credential NAME for it in the keystore's byo/<repo_id>.json (copy that file from the allocating machine — it carries no secret material)" }]);
+            fail("VAULT_BYO_NOT_CONFIGURED", `vault ${repoId} keeps its payload in its own bucket and this machine has no local BYO config for it — ${what} cannot be read`, "reading vault object", { repo_id: repoId, key }, [{ action: "this vault was allocated with `run402 repos create --byo <destination> --profile <name>|--ambient`; this machine needs the same destination and a credential NAME for it in the keystore's byo/<repo_id>.json (copy that file from the allocating machine — it carries no secret material)" }]);
         }
         return backend.get(key);
     }
@@ -809,10 +809,10 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 return bytes;
         }
         if (target.url === undefined)
-            fail("GITVAULT_OBJECT_READ_FAILED", `object-reads entry for ${path} carries neither a presign nor a byo_key`, "reading gitvault object", { path });
-        const r = await fetchGitvaultObjectBytes(client, { url: target.url, ...(target.edge_url ? { edge_url: target.edge_url } : {}) });
+            fail("VAULT_OBJECT_READ_FAILED", `object-reads entry for ${path} carries neither a presign nor a byo_key`, "reading vault object", { path });
+        const r = await fetchVaultObjectBytes(client, { url: target.url, ...(target.edge_url ? { edge_url: target.edge_url } : {}) });
         try {
-            options.onObjectStoreOriginObserved?.(repoId, gitvaultObjectStoreOrigins([target.url, target.edge_url]));
+            options.onObjectStoreOriginObserved?.(repoId, vaultObjectStoreOrigins([target.url, target.edge_url]));
         }
         catch {
             /* a caller's own persistence failure must never surface into this read */
@@ -820,21 +820,21 @@ export function createGitvaultHttpTransport(client, options = {}) {
         if (r.status === 404)
             return null;
         if (!r.ok)
-            fail("GITVAULT_OBJECT_READ_FAILED", `object GET failed (HTTP ${r.status}) for ${path}`, "reading gitvault object", { path, status: r.status });
+            fail("VAULT_OBJECT_READ_FAILED", `object GET failed (HTTP ${r.status}) for ${path}`, "reading vault object", { path, status: r.status });
         return new Uint8Array(await r.arrayBuffer());
     }
     /** Presign + fetch one object by its ledger identity (`POST …/object-reads`). */
     async function getObjectBytes(repoId, path, expectedSha256) {
-        const ref = gitvaultWireRefForPath(path);
+        const ref = vaultWireRefForPath(path);
         if (!ref)
-            fail("GITVAULT_OBJECT_READ_FAILED", `${path} has no control-plane wire identity; it is not a readable vault object`, "reading gitvault object", { path });
+            fail("VAULT_OBJECT_READ_FAILED", `${path} has no control-plane wire identity; it is not a readable vault object`, "reading vault object", { path });
         if (ref.kind === "head")
             return getGenerationBytes(repoId, "heads", ref.generation);
         if (ref.kind === "admission")
             return getGenerationBytes(repoId, "admissions", ref.generation);
         let presigned;
         try {
-            presigned = await client.request(`${base(repoId)}/object-reads`, { method: "POST", body: { objects: [ref.read] }, context: "resolving gitvault object" });
+            presigned = await client.request(`${base(repoId)}/object-reads`, { method: "POST", body: { objects: [ref.read] }, context: "resolving vault object" });
         }
         catch (e) {
             if (isRun402Error(e) && e.status === 404)
@@ -849,7 +849,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
             // (older/staging) gateway behind RUN402_API_BASE, so name it rather
             // than letting it read as a client validation bug.
             if (ref.read.object_kind === "recipient_pin_manifest" && isRun402Error(e) && e.code === "VALIDATION_FAILED" && /epoch must be 16 hex/.test(e.message ?? "")) {
-                throw new LocalError(`this gateway predates the 2026-08-28 fix that made object-reads accept recipient_pin_manifest reads by pin_manifest_version (its null-idScalar branch rejected them with key_envelope's epoch-shape complaint) — this vault's pin manifest at ${path} cannot be read back over the network from it by a keystore that did not itself just publish the manifest`, "reading gitvault object", { code: "GITVAULT_PIN_MANIFEST_READ_UNSUPPORTED", details: { path, pin_manifest_version: ref.read.pin_manifest_version }, cause: e });
+                throw new LocalError(`this gateway predates the 2026-08-28 fix that made object-reads accept recipient_pin_manifest reads by pin_manifest_version (its null-idScalar branch rejected them with key_envelope's epoch-shape complaint) — this vault's pin manifest at ${path} cannot be read back over the network from it by a keystore that did not itself just publish the manifest`, "reading vault object", { code: "VAULT_PIN_MANIFEST_READ_UNSUPPORTED", details: { path, pin_manifest_version: ref.read.pin_manifest_version }, cause: e });
             }
             throw e;
         }
@@ -859,9 +859,9 @@ export function createGitvaultHttpTransport(client, options = {}) {
         return resolveObjectReadTarget(repoId, target, expectedSha256, path);
     }
     /**
-     * Presign + fetch N independent objects (gitvault-client-round-trips
+     * Presign + fetch N independent objects (vault-client-round-trips
      * design D2): ONE `object-reads` POST naming every path, then the GETs
-     * with bounded concurrency ({@link GITVAULT_TRANSPORT_CONCURRENCY}).
+     * with bounded concurrency ({@link VAULT_TRANSPORT_CONCURRENCY}).
      * Every path must be `object-reads`-addressed (a "carrier": ref_state,
      * retention_roots, a WAL/checkpoint pack, …) — a generation-addressed
      * head/admission path has no place in a batch built for materialize/
@@ -874,7 +874,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
         const targets = await presignObjectBatch(repoId, paths);
         if (!targets)
             return paths.map(() => null);
-        return mapBounded(targets, GITVAULT_TRANSPORT_CONCURRENCY, async (target, i) => {
+        return mapBounded(targets, VAULT_TRANSPORT_CONCURRENCY, async (target, i) => {
             if (!target)
                 return null;
             return resolveObjectReadTarget(repoId, target, expected?.[i], paths[i]);
@@ -883,14 +883,14 @@ export function createGitvaultHttpTransport(client, options = {}) {
     /** The shared presign step of the batched read: ONE `object-reads` POST; `null` means the not-found shapes `getObjects` maps to an all-absent result. */
     async function presignObjectBatch(repoId, paths) {
         const refs = paths.map((path) => {
-            const ref = gitvaultWireRefForPath(path);
+            const ref = vaultWireRefForPath(path);
             if (!ref || ref.kind !== "object")
-                fail("GITVAULT_OBJECT_READ_FAILED", `${path} is not a batch-readable carrier object`, "reading gitvault objects", { path });
+                fail("VAULT_OBJECT_READ_FAILED", `${path} is not a batch-readable carrier object`, "reading vault objects", { path });
             return ref.read;
         });
         let presigned;
         try {
-            presigned = await client.request(`${base(repoId)}/object-reads`, { method: "POST", body: { objects: refs }, context: "resolving gitvault objects" });
+            presigned = await client.request(`${base(repoId)}/object-reads`, { method: "POST", body: { objects: refs }, context: "resolving vault objects" });
         }
         catch (e) {
             if (isRun402Error(e) && e.status === 404)
@@ -899,16 +899,16 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 return null;
             throw e;
         }
-        const byLedgerId = new Map(presigned.reads.map((r) => [gitvaultLedgerId(r), r]));
-        return refs.map((r) => byLedgerId.get(gitvaultLedgerId(r)) ?? null);
+        const byLedgerId = new Map(presigned.reads.map((r) => [vaultLedgerId(r), r]));
+        return refs.map((r) => byLedgerId.get(vaultLedgerId(r)) ?? null);
     }
     /**
-     * Per-object settlement over the same batch (gitvault-pipelined-restore
+     * Per-object settlement over the same batch (vault-pipelined-restore
      * D2): identical presign + bounded GETs, but each index's promise settles
      * when ITS bytes land. Failure semantics per index match `getObjects`'s
      * per-element behavior (absent → null, a failed GET → the same
-     * GITVAULT_OBJECT_READ_FAILED), including `expected` (gitvault-small-
-     * object-inline design D3 — see {@link GitvaultTransport.getObjects}'s
+     * VAULT_OBJECT_READ_FAILED), including `expected` (vault-small-
+     * object-inline design D3 — see {@link VaultTransport.getObjects}'s
      * doc comment); every promise is pre-marked handled so an abandoned tail
      * never becomes an unhandled rejection.
      */
@@ -948,12 +948,12 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 }
             }
         };
-        void Promise.all(Array.from({ length: Math.min(GITVAULT_TRANSPORT_CONCURRENCY, targets.length) }, () => worker()));
+        void Promise.all(Array.from({ length: Math.min(VAULT_TRANSPORT_CONCURRENCY, targets.length) }, () => worker()));
         return deferreds.map((d) => d.promise);
     }
     /**
      * `POST …/head-reads` — many generation-addressed heads' EXACT stored bytes
-     * in ONE round trip (gitvault-batched-head-reads task 4.1).
+     * in ONE round trip (vault-batched-head-reads task 4.1).
      *
      * `null` means UNSUPPORTED, and it is deliberately the answer to EVERY
      * failure shape: a 404 from a gateway that predates the route, a refusal, a
@@ -979,7 +979,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
             const res = await client.request(`${base(repoId)}/head-reads`, {
                 method: "POST",
                 body: { generations },
-                context: "reading gitvault heads in a batch",
+                context: "reading vault heads in a batch",
             });
             const byGeneration = new Map();
             for (const h of res.heads ?? []) {
@@ -1007,15 +1007,15 @@ export function createGitvaultHttpTransport(client, options = {}) {
             return null;
         }
     }
-    /** Resolve ONE `GET …/state` carrier arm to raw bytes — inline decode, or a plain GET on the presigned URL (preferring its `edge_url` companion, gitvault-read-edge-cache design D5), `null` on a 404 (mirrors {@link getObjectBytes}'s absent reading; both arms indistinguishable after this). Origin observation (gitvault-object-host-predial task 1.2) mirrors `resolveObjectReadTarget`'s. */
+    /** Resolve ONE `GET …/state` carrier arm to raw bytes — inline decode, or a plain GET on the presigned URL (preferring its `edge_url` companion, vault-read-edge-cache design D5), `null` on a 404 (mirrors {@link getObjectBytes}'s absent reading; both arms indistinguishable after this). Origin observation (vault-object-host-predial task 1.2) mirrors `resolveObjectReadTarget`'s. */
     async function resolveVaultStateCarrier(repoId, carrier) {
         if ("byo_key" in carrier)
             return readByoObject(repoId, carrier.byo_key, "vault-state carrier");
         if ("inline" in carrier)
             return fromBase64url(carrier.inline, "carriers.inline");
-        const r = await fetchGitvaultObjectBytes(client, { url: carrier.presigned_url, edge_url: carrier.edge_url });
+        const r = await fetchVaultObjectBytes(client, { url: carrier.presigned_url, edge_url: carrier.edge_url });
         try {
-            options.onObjectStoreOriginObserved?.(repoId, gitvaultObjectStoreOrigins([carrier.presigned_url, carrier.edge_url]));
+            options.onObjectStoreOriginObserved?.(repoId, vaultObjectStoreOrigins([carrier.presigned_url, carrier.edge_url]));
         }
         catch {
             /* a caller's own persistence failure must never surface into this read */
@@ -1023,14 +1023,14 @@ export function createGitvaultHttpTransport(client, options = {}) {
         if (r.status === 404)
             return null;
         if (!r.ok)
-            fail("GITVAULT_OBJECT_READ_FAILED", `vault-state carrier GET failed (HTTP ${r.status})`, "reading the gitvault vault state", { status: r.status });
+            fail("VAULT_OBJECT_READ_FAILED", `vault-state carrier GET failed (HTTP ${r.status})`, "reading the vault state", { status: r.status });
         return new Uint8Array(await r.arrayBuffer());
     }
     /**
      * `GET …/state` (design D1): one JSON body carrying the vault record, the
      * newest generation, its head's exact stored bytes, and both carriers —
      * resolved to raw bytes here, verified nowhere here (see the interface's
-     * own doc comment on {@link GitvaultTransport.getState}).
+     * own doc comment on {@link VaultTransport.getState}).
      */
     async function getVaultStateOut(repoId, since, restore) {
         const qs = [];
@@ -1038,14 +1038,14 @@ export function createGitvaultHttpTransport(client, options = {}) {
             qs.push(`since=${encodeURIComponent(since)}`);
         if (restore)
             qs.push("restore=1");
-        const raw = await client.request(`${base(repoId)}/state${qs.length > 0 ? `?${qs.join("&")}` : ""}`, { context: "reading the gitvault vault state" });
+        const raw = await client.request(`${base(repoId)}/state${qs.length > 0 ? `?${qs.join("&")}` : ""}`, { context: "reading the vault state" });
         const head = raw.head ? { stored_bytes: fromBase64url(raw.head.stored_bytes, "head.stored_bytes"), stored_bytes_sha256: raw.head.stored_bytes_sha256 } : null;
         const carriers = raw.carriers
             ? { ref_state: await resolveVaultStateCarrier(repoId, raw.carriers.ref_state), retention_roots: await resolveVaultStateCarrier(repoId, raw.carriers.retention_roots) }
             : null;
         // Delta decode is deliberately forgiving: a malformed entry is dropped,
         // never thrown — the delta is an accelerator and the ordinary reads own
-        // every failure mode (gitvault-delta-fetch D2/D4).
+        // every failure mode (vault-delta-fetch D2/D4).
         let delta = null;
         if (raw.delta && Array.isArray(raw.delta.heads) && Array.isArray(raw.delta.packs)) {
             try {
@@ -1061,7 +1061,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 delta = null;
             }
         }
-        // Restore-plan decode (gitvault-restore-recipe design D1-D5): the SAME
+        // Restore-plan decode (vault-restore-recipe design D1-D5): the SAME
         // forgiving posture as `delta` above — ANY structural or resolution
         // anomaly drops the whole plan, never throws, so a hiccup fetching one
         // above-cap pack never fails the state read itself (head/carriers/delta
@@ -1097,11 +1097,11 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 const packEntries = rp.packs.filter((pk) => typeof pk?.object_kind === "string" && typeof pk.object_id === "string");
                 if (packEntries.length !== rp.packs.length)
                     return null; // a malformed pack entry disqualifies the whole plan
-                const resolved = await mapBounded(packEntries, GITVAULT_TRANSPORT_CONCURRENCY, async (pk) => {
+                const resolved = await mapBounded(packEntries, VAULT_TRANSPORT_CONCURRENCY, async (pk) => {
                     const target = { object_kind: pk.object_kind, object_id: pk.object_id, url: pk.url ?? "", edge_url: pk.edge_url, inline: pk.inline, stored_bytes_sha256: pk.stored_bytes_sha256 ?? "", size_bytes: pk.size_bytes ?? "0", expires_at: pk.expires_at ?? "" };
                     // Self-consistency only (the same gate `inline` gets everywhere
                     // else) — real verification against the head/manifest's OWN
-                    // receipt happens later, in `GitvaultVault`, before any byte is
+                    // receipt happens later, in `Vault`, before any byte is
                     // trusted. A pack the gateway declined to presign (`url` absent,
                     // `inline` absent) is `null` here and falls back to the ordinary
                     // object-reads fetch by (object_kind, object_id) in the caller.
@@ -1121,12 +1121,12 @@ export function createGitvaultHttpTransport(client, options = {}) {
     }
     /** Pair a `finalize`-shaped response's receipts back onto `objects` by ledger id — shared by the inline and presigned upload paths so neither forks the other's receipt-compare logic. */
     function receiptsFromFinalize(objects, entries, fin) {
-        const receipts = new Map(fin.receipts.map((r) => [gitvaultLedgerId(r), r]));
+        const receipts = new Map(fin.receipts.map((r) => [vaultLedgerId(r), r]));
         return objects.map((o, i) => {
-            const id = gitvaultLedgerId(entries[i]);
+            const id = vaultLedgerId(entries[i]);
             const r = receipts.get(id);
             if (!r)
-                fail("GITVAULT_RECEIPT_MISSING", `finalize returned no receipt for ${id}`, "finalizing gitvault upload session", { object_id: id, path: o.path });
+                fail("VAULT_RECEIPT_MISSING", `finalize returned no receipt for ${id}`, "finalizing vault upload session", { object_id: id, path: o.path });
             return { path: o.path, object_id: o.object_id, sha256: r.ciphertext_sha256 ?? r.stored_bytes_sha256 ?? "", size_bytes: r.size_bytes };
         });
     }
@@ -1136,15 +1136,15 @@ export function createGitvaultHttpTransport(client, options = {}) {
         // The manifest is closed-key: `path` is client-local and MUST NOT ride the
         // wire — the control plane derives the bucket key itself and refuses an
         // entry carrying an unexpected member.
-        const entries = objects.map((o) => gitvaultManifestEntry(o));
-        // gitvault-byo-primary-bucket task 3.2: the inline (bytes-in-body) fast
+        const entries = objects.map((o) => vaultManifestEntry(o));
+        // vault-byo-primary-bucket task 3.2: the inline (bytes-in-body) fast
         // path is NEVER used for a BYO vault, even when the payload is small
         // enough to be eligible — that transport writes bytes into run402's own
         // bucket, exactly what the credential model forbids (the gateway
         // refuses it too, VALIDATION_FAILED, so skipping it here is purely a
         // wasted-round-trip avoidance, not a correctness dependency).
-        if (!byo && gitvaultInlineUploadEligible(objects)) {
-            // gitvault-composite-state-read design D2: every object fits under the
+        if (!byo && vaultInlineUploadEligible(objects)) {
+            // vault-composite-state-read design D2: every object fits under the
             // caps — one POST, bytes verified + written server-side, and the
             // response IS the finalize response (no session, no PUTs, no separate
             // finalize call). Same closed-key manifest as the presigned path, plus
@@ -1152,46 +1152,46 @@ export function createGitvaultHttpTransport(client, options = {}) {
             const fin = await client.request(`${base(repoId)}/upload-sessions`, {
                 method: "POST",
                 body: { objects: entries.map((entry, i) => ({ ...entry, bytes: b64u(objects[i].bytes) })), ...(resourceBinding ? { resource_binding: resourceBinding } : {}) },
-                context: "uploading gitvault objects inline",
+                context: "uploading vault objects inline",
             });
             return receiptsFromFinalize(objects, entries, fin);
         }
         const session = await client.request(`${base(repoId)}/upload-sessions`, {
             method: "POST",
             body: { objects: entries, ...(resourceBinding ? { resource_binding: resourceBinding } : {}) },
-            context: "opening gitvault upload session",
+            context: "opening vault upload session",
         });
-        const issued = new Map(session.objects.map((u) => [gitvaultLedgerId(u), u]));
-        // gitvault-byo-primary-bucket task 3.2 — one backend, opened ONCE, for
+        const issued = new Map(session.objects.map((u) => [vaultLedgerId(u), u]));
+        // vault-byo-primary-bucket task 3.2 — one backend, opened ONCE, for
         // every BYO payload object this session names; `null` `put` never
         // appears in the session response unless `byo` was supplied (the
         // gateway only mints `put: null` for a vault whose storage_profile is
         // "byo", which is exactly when THIS caller must have supplied `byo`
-        // too — see the resolution in `GitvaultVault.uploadAll`).
-        const byoBackend = byo ? openGitvaultDestinationBackend(byo.destination, byo.credential) : null;
+        // too — see the resolution in `Vault.uploadAll`).
+        const byoBackend = byo ? openVaultDestinationBackend(byo.destination, byo.credential) : null;
         const byoAttestations = [];
         // Independent create-only PUTs within one session (design D2) — bounded
         // concurrency, same limit as the batched object reads below.
-        await mapBounded(objects, GITVAULT_TRANSPORT_CONCURRENCY, async (o, i) => {
-            const id = gitvaultLedgerId(entries[i]);
+        await mapBounded(objects, VAULT_TRANSPORT_CONCURRENCY, async (o, i) => {
+            const id = vaultLedgerId(entries[i]);
             const target = issued.get(id);
             if (!target)
-                fail("GITVAULT_UPLOAD_SESSION_INVALID", `the session issued no upload for ${id}`, "uploading gitvault objects", { object_id: id, path: o.path });
+                fail("VAULT_UPLOAD_SESSION_INVALID", `the session issued no upload for ${id}`, "uploading vault objects", { object_id: id, path: o.path });
             if (target.put === null) {
-                // BYO payload object (task 2.2's GITVAULT_BYO_PAYLOAD_KINDS
+                // BYO payload object (task 2.2's VAULT_BYO_PAYLOAD_KINDS
                 // partition, mirrored client-side by the server's own `put: null` +
                 // `key` shape) — the client writes DIRECTLY to its own bucket. No
                 // request to run402 ever carries a customer-bucket credential; no
                 // request to run402 ever carries these bytes either.
                 if (!byoBackend || !target.key) {
-                    fail("GITVAULT_BYO_BUCKET_WRITE_REFUSED", `the session named ${o.path} as a BYO-written object but no BYO write target was resolved`, "uploading gitvault objects", { path: o.path, object_id: id });
+                    fail("VAULT_BYO_BUCKET_WRITE_REFUSED", `the session named ${o.path} as a BYO-written object but no BYO write target was resolved`, "uploading vault objects", { path: o.path, object_id: id });
                 }
                 let put;
                 try {
                     put = await byoBackend.putCreateOnly(target.key, o.bytes);
                 }
                 catch (e) {
-                    fail("GITVAULT_BYO_BUCKET_WRITE_REFUSED", `writing ${o.path} to the BYO destination failed: ${e instanceof Error ? e.message : String(e)}`, "uploading gitvault objects", { path: o.path, key: target.key });
+                    fail("VAULT_BYO_BUCKET_WRITE_REFUSED", `writing ${o.path} to the BYO destination failed: ${e instanceof Error ? e.message : String(e)}`, "uploading vault objects", { path: o.path, key: target.key });
                 }
                 if (!put.created) {
                     // create-only: the key already exists — legal ONLY if it is
@@ -1201,7 +1201,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
                     // compare branch below, and the gateway's own attestation rule).
                     const existing = await byoBackend.get(target.key);
                     if (!existing || sha256Hex(existing) !== o.sha256) {
-                        fail("GITVAULT_BYO_BUCKET_WRITE_REFUSED", `${o.path} already exists in the BYO destination with different bytes`, "uploading gitvault objects", { path: o.path, key: target.key });
+                        fail("VAULT_BYO_BUCKET_WRITE_REFUSED", `${o.path} already exists in the BYO destination with different bytes`, "uploading vault objects", { path: o.path, key: target.key });
                     }
                 }
                 byoAttestations.push({ key: target.key, sha256: o.sha256, size_bytes: o.size_bytes, create_only_result: "created" });
@@ -1222,18 +1222,18 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 // create-only: the key exists — legal only if it is byte-identical (read-and-compare)
                 const existing = await getObjectBytes(repoId, o.path);
                 if (!existing || sha256Hex(existing) !== o.sha256)
-                    fail("GITVAULT_OBJECT_EXISTS_DIFFERENT", `${o.path} already exists with different bytes`, "uploading gitvault objects", { path: o.path });
+                    fail("VAULT_OBJECT_EXISTS_DIFFERENT", `${o.path} already exists with different bytes`, "uploading vault objects", { path: o.path });
                 return;
             }
             if (!r.ok)
-                fail("GITVAULT_UPLOAD_FAILED", `presigned PUT failed (HTTP ${r.status}) for ${o.path}`, "uploading gitvault objects", { path: o.path, status: r.status });
+                fail("VAULT_UPLOAD_FAILED", `presigned PUT failed (HTTP ${r.status}) for ${o.path}`, "uploading vault objects", { path: o.path, status: r.status });
         });
         const fin = await client.request(`${base(repoId)}/upload-sessions/${encodeURIComponent(session.upload_session_id)}/finalize`, {
             method: "POST",
             // Only a BYO session ever carries attestations — an ordinary managed
             // session's finalize body stays `{}`, byte-identical to today.
             body: byo ? { attestations: byoAttestations } : {},
-            context: "finalizing gitvault upload session",
+            context: "finalizing vault upload session",
         });
         return receiptsFromFinalize(objects, entries, fin);
     }
@@ -1242,7 +1242,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
             const r = await client.request(`${base(repoId)}/admissions`, {
                 method: "POST",
                 body: { generation, stored_bytes: b64u(bytes), stored_bytes_sha256: hash, ...extra },
-                context: "admitting gitvault head",
+                context: "admitting vault head",
             });
             return { outcome: "admitted", admission_record_sha256: r.admission_record_sha256, capture_receipt: r.capture_receipt ?? null };
         }
@@ -1261,7 +1261,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
             // The route wraps the signed allocation object under `allocation` and
             // adds routing sugar (`allocation_sha256`, `deduplicated`, next_actions).
             // The vault verifies the SIGNED object, so unwrap it here.
-            const res = await client.request("/gitvault/v1/vaults", { method: "POST", body: request, context: "allocating gitvault" });
+            const res = await client.request("/vaults/v1", { method: "POST", body: request, context: "allocating vault" });
             return res.allocation ?? res;
         },
         async putObject(request) {
@@ -1274,7 +1274,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
         getHeads: ({ repo_id, generations }) => getHeadsBytes(repo_id, generations),
         async admitGenesis(request) {
             try {
-                const r = await admit(request.repo_id, GITVAULT_GENESIS_GENERATION, request.stored_bytes, request.stored_bytes_sha256, { allocation_generation: request.allocation_generation });
+                const r = await admit(request.repo_id, VAULT_GENESIS_GENERATION, request.stored_bytes, request.stored_bytes_sha256, { allocation_generation: request.allocation_generation });
                 if (r.outcome === "admitted")
                     return { outcome: "admitted", admitted_sha256: request.stored_bytes_sha256 };
                 return { outcome: "already_admitted", admitted_sha256: r.winner.stored_bytes_sha256 };
@@ -1285,20 +1285,20 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 throw e;
             }
         },
-        getGenesis: ({ repo_id }) => getObjectBytes(repo_id, `head/${GITVAULT_GENESIS_GENERATION}`),
+        getGenesis: ({ repo_id }) => getObjectBytes(repo_id, `head/${VAULT_GENESIS_GENERATION}`),
         // ── publication (5.4) ──
         async listHeads(request) {
             validateHeadsListingRequest(request);
             const qs = new URLSearchParams({ after_generation: request.after_generation, limit: request.limit });
             if (request.cursor !== undefined)
                 qs.set("cursor", request.cursor);
-            return client.request(`${base(request.repo_id)}/heads?${qs.toString()}`, { context: "listing gitvault heads" });
+            return client.request(`${base(request.repo_id)}/heads?${qs.toString()}`, { context: "listing vault heads" });
         },
         uploadObjects: ({ repo_id, objects, resource_binding, byo }) => upload(repo_id, objects, resource_binding, byo),
         admitHead: (r) => admit(r.repo_id, r.generation, r.stored_bytes, r.stored_bytes_sha256),
-        // Both routes SHIPPED (`routes/gitvault-admission.ts`). `retention-cutoffs`
+        // Both routes SHIPPED (`routes/vault-admission.ts`). `retention-cutoffs`
         // answers `{ticket, receipt, next_actions}`, which IS
-        // `GitvaultRetentionCutoffIssued` plus routing sugar — no unwrap needed.
+        // `VaultRetentionCutoffIssued` plus routing sugar — no unwrap needed.
         requestRetentionCutoff: ({ repo_id, base_head_sha256 }) => client.request(`${base(repo_id)}/retention-cutoffs`, { method: "POST", body: { base_head_sha256 }, context: "requesting retention cutoff ticket" }),
         async exchangeActivationToken({ repo_id, operation_id, capture_receipt }) {
             // The route wraps the SIGNED token under `activation_token` and adds
@@ -1307,10 +1307,10 @@ export function createGitvaultHttpTransport(client, options = {}) {
             // caller verifies the SIGNED object, and `checkActivationTokenBinding`
             // compares nine fields that all live INSIDE it. Passing the envelope on
             // as the token mismatches every one of them
-            // (`GITVAULT_TOKEN_BINDING_MISMATCH`) and the deploy never commits — even
+            // (`VAULT_TOKEN_BINDING_MISMATCH`) and the deploy never commits — even
             // though the envelope's sibling `object_id` makes the shape look close
             // enough to be a plausible token at a glance. Pinned by
-            // `gitvault-wire-shapes.test.ts`.
+            // `vault-wire-shapes.test.ts`.
             const res = await client.request(`${base(repo_id)}/activation-tokens`, { method: "POST", body: { operation_id, capture_receipt }, context: "exchanging capture receipt for activation token" });
             return res.activation_token ?? res;
         },
@@ -1318,38 +1318,38 @@ export function createGitvaultHttpTransport(client, options = {}) {
             const r = await client.request(`${base(repo_id)}/override-completions`, { method: "POST", body: { operation_id, capture_receipt }, context: "submitting override completion" });
             return { cleared: r.advisory_cleared ?? r.cleared ?? false };
         },
-        getVaultRecord: ({ repo_id }) => client.request(base(repo_id), { context: "reading the gitvault record" }),
+        getVaultRecord: ({ repo_id }) => client.request(base(repo_id), { context: "reading the vault record" }),
         getState: ({ repo_id, since, restore }) => getVaultStateOut(repo_id, since, restore),
-        openCompactionGrant: ({ repo_id }) => client.request(`${base(repo_id)}/compaction-grant`, { method: "POST", context: "opening the gitvault compaction headroom grant" }),
+        openCompactionGrant: ({ repo_id }) => client.request(`${base(repo_id)}/compaction-grant`, { method: "POST", context: "opening the vault compaction headroom grant" }),
         closeCompactionGrant: async ({ repo_id }) => {
-            const r = await client.request(`${base(repo_id)}/compaction-grant`, { method: "DELETE", context: "closing the gitvault compaction headroom grant" });
+            const r = await client.request(`${base(repo_id)}/compaction-grant`, { method: "DELETE", context: "closing the vault compaction headroom grant" });
             return { closed: r.closed === true };
         },
-        findVaultByProject: ({ project_id }) => client.request(`/gitvault/v1/vaults?project_id=${encodeURIComponent(project_id)}`, { context: "resolving the project's gitvault" }),
-        findVaultByRepo: ({ org_slug, repo_name }) => client.request(`/gitvault/v1/vaults?repo=${encodeURIComponent(`${org_slug}/${repo_name}`)}`, { context: "resolving the gitvault by repo address" }),
+        findVaultByProject: ({ project_id }) => client.request(`/vaults/v1?project_id=${encodeURIComponent(project_id)}`, { context: "resolving the project's vault" }),
+        findVaultByRepo: ({ org_slug, repo_name }) => client.request(`/vaults/v1?repo=${encodeURIComponent(`${org_slug}/${repo_name}`)}`, { context: "resolving the vault by repo address" }),
         listOrgEncryptionKeys: ({ org_id }) => client.request(`/orgs/v1/${encodeURIComponent(org_id)}/encryption-keys`, { context: "reading the org encryption-key directory" }),
-        listEnvelopeRecipients: ({ repo_id }) => client.request(`${base(repo_id)}/envelope-recipients`, { context: "reading the gitvault envelope recipients" }),
+        listEnvelopeRecipients: ({ repo_id }) => client.request(`${base(repo_id)}/envelope-recipients`, { context: "reading the vault envelope recipients" }),
         // ── epoch rotation (D193-D203, rev 42, §9.2) ──
         async createRotationAttempt({ repo_id, descriptor }) {
             const res = await client.request(`${base(repo_id)}/rotation-attempts`, {
                 method: "POST",
                 body: descriptor,
-                context: "creating a gitvault rotation attempt",
+                context: "creating a vault rotation attempt",
             });
             return { rotation_id: res.rotation_id, descriptor: res.descriptor, deduplicated: res.deduplicated ?? false };
         },
-        confirmRecipient: ({ repo_id, principal_id, new_fingerprint }) => client.request(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/confirm`, { method: "POST", body: { new_fingerprint }, context: "confirming a gitvault recipient's first pin" }),
-        repinRecipient: ({ repo_id, principal_id, old_ek_fingerprint, new_fingerprint }) => client.request(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/repin`, { method: "POST", body: { old_ek_fingerprint, new_fingerprint }, context: "re-pinning a gitvault recipient" }),
-        declareRecipientKeyRevoked: ({ repo_id, principal_id }) => client.request(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/key-revocation`, { method: "POST", body: {}, context: "declaring a gitvault recipient key revoked" }),
-        declareEpochSecretExposed: ({ repo_id }) => client.request(`${base(repo_id)}/epoch-secret-exposure`, { method: "POST", body: {}, context: "declaring a gitvault epoch secret exposed" }),
-        declareWriterAuthorityUnavailable: ({ repo_id }) => client.request(`${base(repo_id)}/writer-authority/declare-unavailable`, { method: "POST", body: {}, context: "declaring gitvault writer authority unavailable" }),
+        confirmRecipient: ({ repo_id, principal_id, new_fingerprint }) => client.request(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/confirm`, { method: "POST", body: { new_fingerprint }, context: "confirming a vault recipient's first pin" }),
+        repinRecipient: ({ repo_id, principal_id, old_ek_fingerprint, new_fingerprint }) => client.request(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/repin`, { method: "POST", body: { old_ek_fingerprint, new_fingerprint }, context: "re-pinning a vault recipient" }),
+        declareRecipientKeyRevoked: ({ repo_id, principal_id }) => client.request(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/key-revocation`, { method: "POST", body: {}, context: "declaring a vault recipient key revoked" }),
+        declareEpochSecretExposed: ({ repo_id }) => client.request(`${base(repo_id)}/epoch-secret-exposure`, { method: "POST", body: {}, context: "declaring a vault epoch secret exposed" }),
+        declareWriterAuthorityUnavailable: ({ repo_id }) => client.request(`${base(repo_id)}/writer-authority/declare-unavailable`, { method: "POST", body: {}, context: "declaring vault writer authority unavailable" }),
         async submitOpenProof({ repo_id, principal_id, ek_fingerprint, chain_verified_to_generation, decryptable_to_generation, reader_entrypoint }) {
             // requestWithResponse (not request) — the gateway's own status code is
             // the ONLY signal distinguishing a fresh mint (201) from an idempotent
             // replay of the tuple's already-committed winner (200); the receipt
-            // BODY is identical either way (routes/gitvault.ts:
+            // BODY is identical either way (routes/repos.ts:
             // `res.status(inserted ? 201 : 200).json(receipt)`).
-            const res = await client.requestWithResponse(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/proof-of-open`, { method: "POST", body: { ek_fingerprint, chain_verified_to_generation, decryptable_to_generation, reader_entrypoint }, context: "submitting a gitvault proof-of-open receipt" });
+            const res = await client.requestWithResponse(`${base(repo_id)}/recipients/${encodeURIComponent(principal_id)}/proof-of-open`, { method: "POST", body: { ek_fingerprint, chain_verified_to_generation, decryptable_to_generation, reader_entrypoint }, context: "submitting a vault proof-of-open receipt" });
             return { receipt: res.body, deduplicated: res.status === 200 };
         },
         acquireMaintenanceLease: ({ repo_id, base_head_sha256, current_checkpoint_hash, r1_size_bytes, r2_cap_size_bytes, p_before_c1_size_bytes, p_before_c2_size_bytes }) => client.request(`${base(repo_id)}/maintenance-leases`, {
@@ -1362,10 +1362,10 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 p_before_c1_size_bytes: p_before_c1_size_bytes ?? "0",
                 p_before_c2_size_bytes: p_before_c2_size_bytes ?? "0",
             },
-            context: "acquiring the gitvault maintenance lease",
+            context: "acquiring the vault maintenance lease",
         }),
-        heartbeatMaintenanceLease: ({ repo_id, maintenance_lease_id, holder_token }) => client.request(`${base(repo_id)}/maintenance-leases/${encodeURIComponent(maintenance_lease_id)}/heartbeat`, { method: "POST", body: { holder_token }, context: "renewing the gitvault maintenance lease" }),
-        releaseMaintenanceLease: ({ repo_id, maintenance_lease_id, holder_token }) => client.request(`${base(repo_id)}/maintenance-leases/${encodeURIComponent(maintenance_lease_id)}`, { method: "DELETE", body: { holder_token }, context: "releasing the gitvault maintenance lease" }),
+        heartbeatMaintenanceLease: ({ repo_id, maintenance_lease_id, holder_token }) => client.request(`${base(repo_id)}/maintenance-leases/${encodeURIComponent(maintenance_lease_id)}/heartbeat`, { method: "POST", body: { holder_token }, context: "renewing the vault maintenance lease" }),
+        releaseMaintenanceLease: ({ repo_id, maintenance_lease_id, holder_token }) => client.request(`${base(repo_id)}/maintenance-leases/${encodeURIComponent(maintenance_lease_id)}`, { method: "DELETE", body: { holder_token }, context: "releasing the vault maintenance lease" }),
         // ── prune (§7.3) ──
         async submitPruneIntent({ repo_id, intent_bytes }) {
             // Deliberately NOT `client.request`: that serializes a body object, and
@@ -1374,7 +1374,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
             // object would change what was signed. Same raw-fetch shape the
             // generation-addressed reads use, so it inherits the same credentials.
             const path = `${base(repo_id)}/prune-intents`;
-            const auth = (await client.credentials.getAuth(path, { method: "gitvault.prune" })) ?? {};
+            const auth = (await client.credentials.getAuth(path, { method: "repos.prune" })) ?? {};
             const r = await client.fetch(`${client.apiBase}${path}`, {
                 method: "POST",
                 headers: { ...auth, "content-type": "application/json", accept: "application/json" },
@@ -1398,7 +1398,7 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 // envelope were `{error: {code, message, details}}` — always missed,
                 // so EVERY refusal (receipt-id reuse, the retention floor,
                 // GC_EPOCH_STALE, …) collapsed to the same opaque
-                // `GITVAULT_PRUNE_SUBMIT_FAILED {details: null}`. Read the real
+                // `VAULT_PRUNE_SUBMIT_FAILED {details: null}`. Read the real
                 // shape so the gateway's own refusal rides through verbatim; this
                 // wrapper only adds the HTTP status, never replaces content.
                 const envelope = parsed;
@@ -1415,14 +1415,14 @@ export function createGitvaultHttpTransport(client, options = {}) {
                 details.http_status = r.status;
                 if (envelope?.trace_id)
                     details.trace_id = envelope.trace_id;
-                fail(envelope?.code ?? "GITVAULT_PRUNE_SUBMIT_FAILED", envelope?.message ?? (typeof envelope?.error === "string" ? envelope.error : undefined) ?? `prune intent submission failed (HTTP ${r.status})`, "submitting the gitvault prune intent", details, Array.isArray(envelope?.next_actions) ? envelope.next_actions : undefined);
+                fail(envelope?.code ?? "VAULT_PRUNE_SUBMIT_FAILED", envelope?.message ?? (typeof envelope?.error === "string" ? envelope.error : undefined) ?? `prune intent submission failed (HTTP ${r.status})`, "submitting the vault prune intent", details, Array.isArray(envelope?.next_actions) ? envelope.next_actions : undefined);
             }
             const body = (parsed ?? {});
             return { ...body, stored: body.stored === true };
         },
         async getPruneIntent({ repo_id, prune_intent_object_id }) {
             try {
-                return await client.request(`${base(repo_id)}/prune-intents/${encodeURIComponent(prune_intent_object_id)}`, { context: "reading the gitvault prune intent" });
+                return await client.request(`${base(repo_id)}/prune-intents/${encodeURIComponent(prune_intent_object_id)}`, { context: "reading the vault prune intent" });
             }
             catch (e) {
                 // Authorize-before-reveal: a malformed, absent, or foreign id all
@@ -1433,10 +1433,10 @@ export function createGitvaultHttpTransport(client, options = {}) {
             }
         },
     };
-    return process.env.RUN402_GITVAULT_TRACE === "1" ? traceGitvaultTransport(transport) : transport;
+    return process.env.RUN402_VAULT_TRACE === "1" ? traceVaultTransport(transport) : transport;
 }
 /**
- * `RUN402_GITVAULT_TRACE=1` (design D7) — one stderr line per real
+ * `RUN402_VAULT_TRACE=1` (design D7) — one stderr line per real
  * transport operation (op kind, a path/object-count shape when the request
  * carries one, byte count when the result carries one, duration) plus a
  * session summary at process exit (total ops, total time spent in this
@@ -1445,17 +1445,17 @@ export function createGitvaultHttpTransport(client, options = {}) {
  * `git-remote-run402` protocol stream, the same discipline the helper's
  * own `note()` follows — and not a canonical surface: it is NOT what the
  * client-surface spec's counted budgets measure (that is
- * `GitvaultOpCounter`, a test-only instrument over the SAME operation
+ * `VaultOpCounter`, a test-only instrument over the SAME operation
  * shapes). The client-side env var carries no gateway env-registry policy.
  */
-function traceGitvaultTransport(inner) {
+function traceVaultTransport(inner) {
     let opCount = 0;
     let totalMs = 0;
     const sessionStart = Date.now();
     process.on("exit", () => {
         if (opCount === 0)
             return;
-        process.stderr.write(`gitvault-trace: session summary — ${opCount} op(s), ${totalMs.toFixed(1)}ms in transport, ${Date.now() - sessionStart}ms wall-clock\n`);
+        process.stderr.write(`vault-trace: session summary — ${opCount} op(s), ${totalMs.toFixed(1)}ms in transport, ${Date.now() - sessionStart}ms wall-clock\n`);
     });
     const describeRequest = (arg) => {
         if (!arg || typeof arg !== "object")
@@ -1494,14 +1494,14 @@ function traceGitvaultTransport(inner) {
                     const elapsed = Date.now() - start;
                     opCount += 1;
                     totalMs += elapsed;
-                    process.stderr.write(`gitvault-trace: ${prop}${describeRequest(args[0])}${describeResult(result)} ${elapsed}ms\n`);
+                    process.stderr.write(`vault-trace: ${prop}${describeRequest(args[0])}${describeResult(result)} ${elapsed}ms\n`);
                     return result;
                 }
                 catch (e) {
                     const elapsed = Date.now() - start;
                     opCount += 1;
                     totalMs += elapsed;
-                    process.stderr.write(`gitvault-trace: ${prop}${describeRequest(args[0])} FAILED ${elapsed}ms\n`);
+                    process.stderr.write(`vault-trace: ${prop}${describeRequest(args[0])} FAILED ${elapsed}ms\n`);
                     throw e;
                 }
             };
@@ -1509,7 +1509,7 @@ function traceGitvaultTransport(inner) {
     });
 }
 // ─── Storage paths (§3) ──────────────────────────────────────────────────────
-export const gitvaultPaths = {
+export const vaultPaths = {
     head: (generation) => `head/${generation}`,
     admission: (generation) => `admissions/${generation}`,
     wal: (id) => `wal/${id}.pack.enc`,
@@ -1523,7 +1523,7 @@ export const gitvaultPaths = {
     verifierReceipt: (id) => `verifier-receipts/${id}.json`,
     /**
      * `envelopes/<epoch>/<recipient_fingerprint>` — mirrors
-     * `gitvault-creation-journal.ts`'s private `envelopePath` (the genesis
+     * `vault-creation-journal.ts`'s private `envelopePath` (the genesis
      * creator's envelope); this is the same addressing for every OTHER
      * recipient's `key_envelope`. `rotationId` present (D195, rev 42) widens
      * this to `envelopes/<epoch>/<rotation_id>/<recipient_fingerprint>` — a
@@ -1534,7 +1534,7 @@ export const gitvaultPaths = {
     /** `recipient-pins/<pin_manifest_version>.json` (D197, rev 42) — version-addressed, plaintext-structured, writer-signed. */
     pinManifest: (pinManifestVersion) => `recipient-pins/${pinManifestVersion}.json`,
 };
-// ─── Incremental restore marker (gitvault-client-round-trips design D5) ──────
+// ─── Incremental restore marker (vault-client-round-trips design D5) ──────
 //
 // `restored_through` — the newest generation whose WAL packs this TARGET
 // DIRECTORY has fully applied — is local git state, same store as the
@@ -1542,8 +1542,8 @@ export const gitvaultPaths = {
 // actually wrote into (never `process.cwd()`, and never scoped to `repo_id`:
 // a re-pointed remote's marker simply fails its `head_sha256` comparison and
 // falls back to wholesale, safely, since that comparison is a content hash).
-const GITVAULT_RESTORE_MARKER_GENERATION_KEY = "r402.restoredThrough";
-const GITVAULT_RESTORE_MARKER_SHA256_KEY = "r402.restoredThroughSha256";
+const VAULT_RESTORE_MARKER_GENERATION_KEY = "r402.restoredThrough";
+const VAULT_RESTORE_MARKER_SHA256_KEY = "r402.restoredThroughSha256";
 async function readLocalGitConfigValue(dir, key) {
     try {
         const out = (await hardenedGit(dir, ["config", "--local", "--get", key])).text().trim();
@@ -1555,49 +1555,49 @@ async function readLocalGitConfigValue(dir, key) {
     }
 }
 /** Read this target directory's `restored_through` marker, or `null` when nothing was ever restored into it. */
-export async function readGitvaultRestoreMarker(targetRepoDir) {
-    const generation = await readLocalGitConfigValue(targetRepoDir, GITVAULT_RESTORE_MARKER_GENERATION_KEY);
-    const head_sha256 = await readLocalGitConfigValue(targetRepoDir, GITVAULT_RESTORE_MARKER_SHA256_KEY);
+export async function readVaultRestoreMarker(targetRepoDir) {
+    const generation = await readLocalGitConfigValue(targetRepoDir, VAULT_RESTORE_MARKER_GENERATION_KEY);
+    const head_sha256 = await readLocalGitConfigValue(targetRepoDir, VAULT_RESTORE_MARKER_SHA256_KEY);
     if (!generation || !head_sha256)
         return null;
     return { generation, head_sha256 };
 }
 /** Advance the marker — called only after a restore's coverage verification succeeds. */
-async function writeGitvaultRestoreMarker(targetRepoDir, generation, headSha256) {
-    await hardenedGit(targetRepoDir, ["config", "--local", GITVAULT_RESTORE_MARKER_GENERATION_KEY, generation]);
-    await hardenedGit(targetRepoDir, ["config", "--local", GITVAULT_RESTORE_MARKER_SHA256_KEY, headSha256]);
+async function writeVaultRestoreMarker(targetRepoDir, generation, headSha256) {
+    await hardenedGit(targetRepoDir, ["config", "--local", VAULT_RESTORE_MARKER_GENERATION_KEY, generation]);
+    await hardenedGit(targetRepoDir, ["config", "--local", VAULT_RESTORE_MARKER_SHA256_KEY, headSha256]);
 }
-// ─── auto-gc cadence threshold (gitvault-checkpoint-cadence design D1) ───────
+// ─── auto-gc cadence threshold (vault-checkpoint-cadence design D1) ───────
 //
 // `auto_gc_generations` rides the SAME local-git-config mechanism as the
 // restore marker above — a per-CHECKOUT knob, exactly like git's own
 // `gc.auto` (`git config gc.auto`), not a server-side vault policy. Read
 // fresh every push (a cheap local read, never network); `0` disables;
 // absent reads as the default.
-const GITVAULT_AUTO_GC_GENERATIONS_KEY = "r402.autoGcGenerations";
+const VAULT_AUTO_GC_GENERATIONS_KEY = "r402.autoGcGenerations";
 /** Default `auto_gc_generations` — see the change proposal's rationale (≈2-3s over the fresh-checkpoint floor at this backlog, a busy repo compacts roughly once per few dozen pushes). */
-export const GITVAULT_AUTO_GC_GENERATIONS_DEFAULT = 32;
+export const VAULT_AUTO_GC_GENERATIONS_DEFAULT = 32;
 /**
  * Read this checkout's auto-gc threshold, or the default when unset or
  * unparseable. Never throws — a corrupt local config value degrades to the
  * default rather than blocking a push's own auto-gc check.
  */
-export async function readGitvaultAutoGcThreshold(targetRepoDir) {
-    const raw = await readLocalGitConfigValue(targetRepoDir, GITVAULT_AUTO_GC_GENERATIONS_KEY);
+export async function readVaultAutoGcThreshold(targetRepoDir) {
+    const raw = await readLocalGitConfigValue(targetRepoDir, VAULT_AUTO_GC_GENERATIONS_KEY);
     if (raw === null)
-        return GITVAULT_AUTO_GC_GENERATIONS_DEFAULT;
+        return VAULT_AUTO_GC_GENERATIONS_DEFAULT;
     const trimmed = raw.trim();
     if (!/^\d+$/.test(trimmed))
-        return GITVAULT_AUTO_GC_GENERATIONS_DEFAULT;
+        return VAULT_AUTO_GC_GENERATIONS_DEFAULT;
     const n = Number.parseInt(trimmed, 10);
-    return Number.isSafeInteger(n) && n >= 0 ? n : GITVAULT_AUTO_GC_GENERATIONS_DEFAULT;
+    return Number.isSafeInteger(n) && n >= 0 ? n : VAULT_AUTO_GC_GENERATIONS_DEFAULT;
 }
 /** Set this checkout's auto-gc threshold. `0` disables auto-gc entirely. */
-export async function writeGitvaultAutoGcThreshold(targetRepoDir, generations) {
-    await hardenedGit(targetRepoDir, ["config", "--local", GITVAULT_AUTO_GC_GENERATIONS_KEY, String(generations)]);
+export async function writeVaultAutoGcThreshold(targetRepoDir, generations) {
+    await hardenedGit(targetRepoDir, ["config", "--local", VAULT_AUTO_GC_GENERATIONS_KEY, String(generations)]);
 }
 /** A transport-agnostic view of git ops the publication needs (the local repository). */
-export class GitvaultVault {
+export class Vault {
     keystore;
     transport;
     repoId;
@@ -1605,7 +1605,7 @@ export class GitvaultVault {
     now;
     budget;
     /**
-     * gitvault-clone-scaling (bench P2): the CURRENT walk window's prefetched
+     * vault-clone-scaling (bench P2): the CURRENT walk window's prefetched
      * bytes — head bytes (bounded-concurrent direct reads) and carrier frames
      * (one batched getObjects), keyed by storage path — filled by
      * `verifyToNewest`'s per-page prefetch and `restoreObjectsInto`'s
@@ -1622,7 +1622,7 @@ export class GitvaultVault {
      */
     walkPrefetch = null;
     /**
-     * WAL pack bytes carried by the state read's delta (gitvault-delta-fetch),
+     * WAL pack bytes carried by the state read's delta (vault-delta-fetch),
      * keyed by object_id — the walkPrefetch discipline exactly: UNTRUSTED
      * until a consumer's own hash check passes, a mismatch is a plain miss,
      * and the buffer is transient (stashed by {@link tryStateFastPath},
@@ -1630,7 +1630,7 @@ export class GitvaultVault {
      */
     stateDeltaPacks = null;
     /**
-     * The state read's restore plan (gitvault-restore-recipe design D1-D5),
+     * The state read's restore plan (vault-restore-recipe design D1-D5),
      * stashed RAW — never verified at stash time, unlike `stateDeltaPacks`
      * (whose heads self-check before entering the shared keystore cache): a
      * plan's heads/checkpoint/packs are only ever verified by {@link
@@ -1646,7 +1646,7 @@ export class GitvaultVault {
     allowUnauthenticatedSalvage;
     genesisCache = null;
     /**
-     * gitvault-byo-primary-bucket task 3.2 — this vault's resolved BYO write
+     * vault-byo-primary-bucket task 3.2 — this vault's resolved BYO write
      * target, cached after the first resolution (storage_profile/
      * byo_destination are immutable-at-allocation in v1, so a single
      * read-once-per-instance is safe). `undefined` = not yet resolved;
@@ -1661,14 +1661,14 @@ export class GitvaultVault {
         this.repoId = options.repo_id;
         this.repoDir = options.repo_dir ?? null;
         this.now = options.now ?? (() => new Date());
-        this.budget = options.verification_budget ?? GITVAULT_VERIFICATION_BUDGET_HEADS;
-        this.retries = options.conflict_retries ?? GITVAULT_PUSH_CONFLICT_RETRIES;
+        this.budget = options.verification_budget ?? VAULT_VERIFICATION_BUDGET_HEADS;
+        this.retries = options.conflict_retries ?? VAULT_PUSH_CONFLICT_RETRIES;
         this.servicePublicKey = options.service_public_key ?? null;
         this.allowUnauthenticatedSalvage = options.allow_unauthenticated_salvage ?? false;
     }
     static open(options) {
-        const v = new GitvaultVault(options);
-        v.repoFile(); // KEYSTORE_MISSING / GITVAULT_REPO_STATE_MISSING surface here
+        const v = new Vault(options);
+        v.repoFile(); // KEYSTORE_MISSING / VAULT_REPO_STATE_MISSING surface here
         return v;
     }
     repoFile() {
@@ -1678,23 +1678,23 @@ export class GitvaultVault {
         // directory/filename read, appended after the existing remedy rather
         // than replacing it.
         if (!this.keystore.readIdentity()) {
-            fail("KEYSTORE_MISSING", "no gitvault identity in the keystore", "opening gitvault vault", undefined, [
-                { action: "restore ~/.config/run402/gitvault from backup or accept vault loss" },
-                ...crossProfileGitvaultHint(this.repoId),
+            fail("KEYSTORE_MISSING", "no vault identity in the keystore", "opening vault", undefined, [
+                { action: "restore ~/.config/run402/vault from backup or accept vault loss" },
+                ...crossProfileVaultHint(this.repoId),
             ]);
         }
         const repo = this.keystore.readRepo(this.repoId);
         if (!repo) {
-            const hint = crossProfileGitvaultHint(this.repoId);
-            fail("GITVAULT_REPO_STATE_MISSING", `no keystore repo file for ${this.repoId}; restore it from the principal's own envelope (keystore.restoreRepoFromEnvelope)`, "opening gitvault vault", { repo_id: this.repoId }, hint.length > 0 ? hint : undefined);
+            const hint = crossProfileVaultHint(this.repoId);
+            fail("VAULT_REPO_STATE_MISSING", `no keystore repo file for ${this.repoId}; restore it from the principal's own envelope (keystore.restoreRepoFromEnvelope)`, "opening vault", { repo_id: this.repoId }, hint.length > 0 ? hint : undefined);
         }
         return repo;
     }
     /**
-     * gitvault-agent-envelopes D4 — the COLD OPEN. A keystore that holds an
+     * vault-agent-envelopes D4 — the COLD OPEN. A keystore that holds an
      * identity but no repo file for this vault (a member joining from a fresh
      * machine, or a creator whose repo file was lost) restores `K_repo` from
-     * its OWN `key_envelope` instead of dying `GITVAULT_REPO_STATE_MISSING`:
+     * its OWN `key_envelope` instead of dying `VAULT_REPO_STATE_MISSING`:
      *
      *   1. genesis (the writer-key source) is fetched and signature-verified;
      *   2. its creator fingerprints are compared against the control plane's
@@ -1703,10 +1703,10 @@ export class GitvaultVault {
      *      genesis needs a substituted allocation, which the org's owners can
      *      see — TOFU + audit, human-envelopes D4's tier);
      *   3. the envelope-recipients read says whether THIS fingerprint is
-     *      covered — if not, `GITVAULT_ENVELOPE_PENDING` names the key-holders
+     *      covered — if not, `VAULT_ENVELOPE_PENDING` names the key-holders
      *      who can fulfil and the exact next actions (never a terminal error:
      *      the desired state already records this member; any key-holder's
-     *      next gitvault operation wraps);
+     *      next vault operation wraps);
      *   4. the base envelope is fetched, opened, and the repo file written
      *      `restored_from_envelope` with the genesis hash PINNED (a later open
      *      seeing a different genesis for this repo_id refuses
@@ -1719,7 +1719,7 @@ export class GitvaultVault {
      * Returns `null` when the repo file already existed (nothing restored).
      */
     /**
-     * gitvault-multi-writer (rev 47) — the vault's CURRENT admitted writer set
+     * vault-multi-writer (rev 47) — the vault's CURRENT admitted writer set
      * for a cold open, computed from the chain itself: every admitted head is
      * hash-checked against the listing, signature-verified under the writer
      * the chain admits at that point, and its `add_writer_key` /
@@ -1732,9 +1732,9 @@ export class GitvaultVault {
         let writerState = initialWriterState(this.repoId, genesis);
         let prevSha256 = sha256Hex(genesisBytes);
         let prevEpoch = genesis.epoch;
-        let expectedGeneration = nextGeneration(GITVAULT_GENESIS_GENERATION);
-        let progress = { after_generation: GITVAULT_GENESIS_GENERATION, last_generation: GITVAULT_GENESIS_GENERATION, delivered: 0 };
-        let request = { after_generation: GITVAULT_GENESIS_GENERATION, limit: String(GITVAULT_MAX_HEADS_PER_LISTING_PAGE) };
+        let expectedGeneration = nextGeneration(VAULT_GENESIS_GENERATION);
+        let progress = { after_generation: VAULT_GENESIS_GENERATION, last_generation: VAULT_GENESIS_GENERATION, delivered: 0 };
+        let request = { after_generation: VAULT_GENESIS_GENERATION, limit: String(VAULT_MAX_HEADS_PER_LISTING_PAGE) };
         for (;;) {
             const page = await this.transport.listHeads({ repo_id: this.repoId, ...request });
             progress = verifyHeadsListingPage(page, request, progress, this.repoId);
@@ -1742,7 +1742,7 @@ export class GitvaultVault {
                 const bytes = await this.readCachedHeadBytes(entry.generation, entry.stored_bytes_sha256);
                 if (!bytes)
                     fail("CHAIN_BROKEN", `listed head ${entry.generation} is absent from storage`, "resolving the vault's writer set for a cold open", { generation: entry.generation });
-                const head = parseGitvaultStrict(new TextDecoder().decode(bytes));
+                const head = parseVaultStrict(new TextDecoder().decode(bytes));
                 const isWriterAdd = head.transition !== null && head.transition.kind === "add_writer_key";
                 let addWriterKeyPayload = null;
                 let signerPubkey;
@@ -1765,7 +1765,7 @@ export class GitvaultVault {
                 else {
                     const signer = resolveActiveWriter(writerState, head.writer_key_id);
                     if (!signer)
-                        fail("GITVAULT_WRITER_NOT_ADMITTED", `head ${head.generation}: writer_key_id ${head.writer_key_id} is not a currently admitted writer`, "resolving the vault's writer set for a cold open", { generation: head.generation });
+                        fail("VAULT_WRITER_NOT_ADMITTED", `head ${head.generation}: writer_key_id ${head.writer_key_id} is not a currently admitted writer`, "resolving the vault's writer set for a cold open", { generation: head.generation });
                     signerPubkey = signer.signing_pubkey;
                     signerKeyId = signer.writer_key_id;
                 }
@@ -1800,25 +1800,25 @@ export class GitvaultVault {
             return null;
         const identity = this.keystore.readIdentity();
         if (!identity) {
-            fail("KEYSTORE_MISSING", "no gitvault identity in the keystore", "opening gitvault vault", undefined, [
-                { action: "restore ~/.config/run402/gitvault from backup or accept vault loss" },
-                ...crossProfileGitvaultHint(this.repoId),
+            fail("KEYSTORE_MISSING", "no vault identity in the keystore", "opening vault", undefined, [
+                { action: "restore ~/.config/run402/vault from backup or accept vault loss" },
+                ...crossProfileVaultHint(this.repoId),
             ]);
         }
         const ownKeypair = this.keystore.encryptionKeypair(identity);
         if (!ownKeypair) {
-            fail("VAULT_UNRECOVERABLE", GITVAULT_TERMINAL_LOSS_DOCTOR_TEXT, "opening gitvault vault", { statement: GITVAULT_TERMINAL_LOSS_STATEMENT, repo_id: this.repoId });
+            fail("VAULT_UNRECOVERABLE", VAULT_TERMINAL_LOSS_DOCTOR_TEXT, "opening vault", { statement: VAULT_TERMINAL_LOSS_STATEMENT, repo_id: this.repoId });
         }
         const ownFingerprint = identity.encryption_fingerprint;
         const genesisBytes = await this.transport.getGenesis({ repo_id: this.repoId });
         if (!genesisBytes)
-            fail("CHAIN_BROKEN", "the vault has no admitted genesis", "opening gitvault vault", { repo_id: this.repoId });
-        const genesis = parseGitvaultStrict(new TextDecoder().decode(genesisBytes));
-        if (genesis.epoch !== GITVAULT_GENESIS_EPOCH) {
-            fail("VAULT_CREATION_CONFLICT", `the served genesis declares epoch ${genesis.epoch}, not the genesis epoch`, "opening gitvault vault", { repo_id: this.repoId, epoch: genesis.epoch });
+            fail("CHAIN_BROKEN", "the vault has no admitted genesis", "opening vault", { repo_id: this.repoId });
+        const genesis = parseVaultStrict(new TextDecoder().decode(genesisBytes));
+        if (genesis.epoch !== VAULT_GENESIS_EPOCH) {
+            fail("VAULT_CREATION_CONFLICT", `the served genesis declares epoch ${genesis.epoch}, not the genesis epoch`, "opening vault", { repo_id: this.repoId, epoch: genesis.epoch });
         }
         if (genesis.repo_id !== this.repoId) {
-            fail("VAULT_CREATION_CONFLICT", `the served genesis names repo ${genesis.repo_id}, not ${this.repoId}`, "opening gitvault vault", { repo_id: this.repoId, served: genesis.repo_id });
+            fail("VAULT_CREATION_CONFLICT", `the served genesis names repo ${genesis.repo_id}, not ${this.repoId}`, "opening vault", { repo_id: this.repoId, served: genesis.repo_id });
         }
         // Platform-attested creator anchor. The allocation is optional on the
         // wire (older gateways) — absent means the restore is unauthenticated
@@ -1831,13 +1831,13 @@ export class GitvaultVault {
             // downgrade to salvage — it is a refusal. A malicious or broken serving
             // path that cannot forge the SIGNED allocation must not get a vault
             // opened by simply omitting it.
-            fail("GITVAULT_ALLOCATION_UNATTESTED", "the control plane returned no signed allocation record for this vault — refusing an unattested cold restore (recovery flows may opt into explicit unauthenticated salvage)", "opening gitvault vault", { repo_id: this.repoId });
+            fail("VAULT_ALLOCATION_UNATTESTED", "the control plane returned no signed allocation record for this vault — refusing an unattested cold restore (recovery flows may opt into explicit unauthenticated salvage)", "opening vault", { repo_id: this.repoId });
         }
         if (allocation) {
             const genesisEk = ekFingerprint(fromBase64url(genesis.creator_encryption_pubkey, "genesis.creator_encryption_pubkey"));
             const genesisVk = vkFingerprint(fromBase64url(genesis.creator_signing_pubkey, "genesis.creator_signing_pubkey"));
             if (genesisEk !== allocation.creator_encryption_fingerprint || genesisVk !== allocation.creator_signing_fingerprint) {
-                fail("VAULT_CREATION_CONFLICT", "the served genesis's creator keys do not match the control plane's signed allocation record for this vault — refusing a substituted genesis", "opening gitvault vault", { repo_id: this.repoId, genesis_creator_encryption_fingerprint: genesisEk, allocation_creator_encryption_fingerprint: allocation.creator_encryption_fingerprint, genesis_creator_signing_fingerprint: genesisVk, allocation_creator_signing_fingerprint: allocation.creator_signing_fingerprint });
+                fail("VAULT_CREATION_CONFLICT", "the served genesis's creator keys do not match the control plane's signed allocation record for this vault — refusing a substituted genesis", "opening vault", { repo_id: this.repoId, genesis_creator_encryption_fingerprint: genesisEk, allocation_creator_encryption_fingerprint: allocation.creator_encryption_fingerprint, genesis_creator_signing_fingerprint: genesisVk, allocation_creator_signing_fingerprint: allocation.creator_signing_fingerprint });
             }
             allocationAttested = true;
         }
@@ -1857,7 +1857,7 @@ export class GitvaultVault {
                 // best-effort — the refusal is complete without the roster
             }
             const desired = coverage.desired?.find((d) => d.ek_fingerprint === ownFingerprint) ?? null;
-            fail("GITVAULT_ENVELOPE_PENDING", `this keystore (fingerprint ${ownFingerprint}) is not yet a recipient on vault ${this.repoId} — no key_envelope has been wrapped for it; a key-holder's next gitvault operation fulfils the org's desired state`, "opening gitvault vault", {
+            fail("VAULT_ENVELOPE_PENDING", `this keystore (fingerprint ${ownFingerprint}) is not yet a recipient on vault ${this.repoId} — no key_envelope has been wrapped for it; a key-holder's next vault operation fulfils the org's desired state`, "opening vault", {
                 repo_id: this.repoId,
                 org_id: genesis.org_id,
                 own_fingerprint: ownFingerprint,
@@ -1866,16 +1866,16 @@ export class GitvaultVault {
                 covering_recipient_count: coverage.recipient_fingerprints.length,
             }, [
                 { action: "run402 repos access", why: "poll — this_keystore.covered_on_this_vault flips true once a key-holder has wrapped this vault to your key" },
-                { action: "ask a key-holder to run any gitvault operation (run402 repos view / git push)", why: "a key-holding client wraps every pending desired recipient on its next operation; nothing else is required of them" },
+                { action: "ask a key-holder to run any vault operation (run402 repos view / git push)", why: "a key-holding client wraps every pending desired recipient on its next operation; nothing else is required of them" },
             ]);
         }
-        const envelopeBytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.envelope(genesis.epoch, ownFingerprint) });
+        const envelopeBytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.envelope(genesis.epoch, ownFingerprint) });
         if (!envelopeBytes) {
-            fail("GITVAULT_EPOCH_NOT_OPENABLE", `the envelope-recipients read lists this keystore (fingerprint ${ownFingerprint}) as covered, but its base key_envelope could not be retrieved — a server-side or network problem, not a problem with your key; retry`, "opening gitvault vault", { repo_id: this.repoId, epoch: genesis.epoch, recipient_fingerprint: ownFingerprint, reason: "envelope_fetch_failed" });
+            fail("VAULT_EPOCH_NOT_OPENABLE", `the envelope-recipients read lists this keystore (fingerprint ${ownFingerprint}) as covered, but its base key_envelope could not be retrieved — a server-side or network problem, not a problem with your key; retry`, "opening vault", { repo_id: this.repoId, epoch: genesis.epoch, recipient_fingerprint: ownFingerprint, reason: "envelope_fetch_failed" });
         }
-        const envelope = parseGitvaultStrict(new TextDecoder().decode(envelopeBytes));
+        const envelope = parseVaultStrict(new TextDecoder().decode(envelopeBytes));
         if (envelope.repo_id !== this.repoId || envelope.epoch !== genesis.epoch || envelope.recipient_fingerprint !== ownFingerprint) {
-            fail("GITVAULT_ENVELOPE_ALTERED", "the retrieved base key_envelope does not address this vault, epoch, and recipient — refusing to open it", "opening gitvault vault", { repo_id: this.repoId, epoch: genesis.epoch, recipient_fingerprint: ownFingerprint, envelope: { repo_id: envelope.repo_id, epoch: envelope.epoch, recipient_fingerprint: envelope.recipient_fingerprint } });
+            fail("VAULT_ENVELOPE_ALTERED", "the retrieved base key_envelope does not address this vault, epoch, and recipient — refusing to open it", "opening vault", { repo_id: this.repoId, epoch: genesis.epoch, recipient_fingerprint: ownFingerprint, envelope: { repo_id: envelope.repo_id, epoch: envelope.epoch, recipient_fingerprint: envelope.recipient_fingerprint } });
         }
         // rev 47 (writers plural): an envelope wrapped by a non-genesis writer is
         // verified under THAT writer's key, which only the chain can vouch for —
@@ -1898,7 +1898,7 @@ export class GitvaultVault {
     }
     /** {@link open}, but a missing repo file triggers {@link ensureRepoState} first. */
     static async openOrRestore(options) {
-        const v = new GitvaultVault(options);
+        const v = new Vault(options);
         const restored = await v.ensureRepoState();
         v.repoFile();
         return { vault: v, restored };
@@ -1906,7 +1906,7 @@ export class GitvaultVault {
     kRepo() { return hexToBytes(this.repoFile().k_repo_hex); }
     epoch() { return this.repoFile().epoch; }
     /**
-     * gitvault-clone-scaling (P3): staleness of the newest checkpoint coverage
+     * vault-clone-scaling (P3): staleness of the newest checkpoint coverage
      * this checkout has locally learned, measured at `newestGeneration`. Reads
      * the keystore AFTER the caller's own persist (a checkpoint-form push has
      * already recorded its fresh coverage by the time its result is built), so
@@ -1914,13 +1914,13 @@ export class GitvaultVault {
      * the helper; unknown coverage reads as `{0, advised: false}` — silent.
      */
     checkpointStalenessNow(newestGeneration) {
-        return gitvaultCheckpointStaleness({ newest_generation: newestGeneration, covers_through_generation: this.repoFile().checkpoint_covers_through ?? null });
+        return vaultCheckpointStaleness({ newest_generation: newestGeneration, covers_through_generation: this.repoFile().checkpoint_covers_through ?? null });
     }
     /**
      * Fetch many generation-addressed heads' bytes ahead of the ordered walk,
      * keyed by head path.
      *
-     * BATCH-FIRST (gitvault-batched-head-reads task 4.2): one
+     * BATCH-FIRST (vault-batched-head-reads task 4.2): one
      * `POST …/head-reads` carries a whole page's bytes. Heads deliberately do
      * NOT ride `getObjects` — the `object-reads` presign batch is CARRIER-ONLY
      * by wire design (see `getObjectsBytes`'s fail-closed doc comment; the live
@@ -1928,10 +1928,10 @@ export class GitvaultVault {
      * by 25 serial singles), which is exactly why the batch route had to be its
      * own thing.
      *
-     * FALLBACK (the shipped gitvault-clone-scaling P2 shape): on ANY
+     * FALLBACK (the shipped vault-clone-scaling P2 shape): on ANY
      * unsupported answer — an older gateway, a refusal, a fault — head bytes
      * parallelize as the SAME direct GETs the ordered walk itself would issue,
-     * just early and overlapped at {@link GITVAULT_TRANSPORT_CONCURRENCY}. The
+     * just early and overlapped at {@link VAULT_TRANSPORT_CONCURRENCY}. The
      * transport remembers a route-absent verdict, so the probe is paid once per
      * client, not once per window.
      *
@@ -1958,12 +1958,12 @@ export class GitvaultVault {
             for (let i = 0; i < ascending.length; i++) {
                 const b = batched[i];
                 if (b)
-                    map.set(gitvaultPaths.head(ascending[i]), b);
+                    map.set(vaultPaths.head(ascending[i]), b);
             }
             return map;
         }
-        const paths = generations.map((g) => gitvaultPaths.head(g));
-        const fetched = await mapBounded(paths, GITVAULT_TRANSPORT_CONCURRENCY, (path) => this.transport.getObject({ repo_id: this.repoId, path }).catch(() => null));
+        const paths = generations.map((g) => vaultPaths.head(g));
+        const fetched = await mapBounded(paths, VAULT_TRANSPORT_CONCURRENCY, (path) => this.transport.getObject({ repo_id: this.repoId, path }).catch(() => null));
         for (let i = 0; i < paths.length; i++) {
             const b = fetched[i];
             if (b)
@@ -1973,7 +1973,7 @@ export class GitvaultVault {
     }
     git() {
         if (!this.repoDir)
-            fail("GITVAULT_REPO_DIR_REQUIRED", "this operation needs the local git repository (repo_dir)", "gitvault publication");
+            fail("VAULT_REPO_DIR_REQUIRED", "this operation needs the local git repository (repo_dir)", "vault publication");
         return this.repoDir;
     }
     /** Fetch + pin-check the genesis (the writer key source). */
@@ -1992,17 +1992,17 @@ export class GitvaultVault {
                 this.keystore.writeCachedGenesis(this.repoId, repo.genesis_sha256, bytes);
         }
         if (!bytes)
-            fail("CHAIN_BROKEN", "the vault has no admitted genesis", "reading gitvault genesis", { repo_id: this.repoId });
+            fail("CHAIN_BROKEN", "the vault has no admitted genesis", "reading vault genesis", { repo_id: this.repoId });
         const sha256 = sha256Hex(bytes);
         if (sha256 !== repo.genesis_sha256)
-            fail("VAULT_CREATION_CONFLICT", `the admitted genesis (${sha256}) is not the pinned one (${repo.genesis_sha256}); refusing a substituted vault`, "reading gitvault genesis", { admitted: sha256, pinned: repo.genesis_sha256 });
-        const genesis = parseGitvaultStrict(new TextDecoder().decode(bytes));
+            fail("VAULT_CREATION_CONFLICT", `the admitted genesis (${sha256}) is not the pinned one (${repo.genesis_sha256}); refusing a substituted vault`, "reading vault genesis", { admitted: sha256, pinned: repo.genesis_sha256 });
+        const genesis = parseVaultStrict(new TextDecoder().decode(bytes));
         this.genesisCache = { genesis, sha256 };
         return this.genesisCache;
     }
     // ── §6.3/6.4 discovery + verification ──
     /**
-     * gitvault-composite-state-read design D1 — the pin-current fast path
+     * vault-composite-state-read design D1 — the pin-current fast path
      * `verifyToNewest` tries FIRST: one `GET …/state` in place of BOTH the
      * live "server still holds the pin" read {@link readHead} would otherwise
      * perform AND, when eligible, the `listHeads` walk that would follow it.
@@ -2040,12 +2040,12 @@ export class GitvaultVault {
      * {@link openCarrier} already key their own writes) but NEVER trusted
      * here — every reader downstream re-verifies a cache hit against the hash
      * it would check network bytes against before using it (this file's own
-     * established cache discipline; see `GitvaultKeystore`'s class doc
+     * established cache discipline; see `VaultKeystore`'s class doc
      * comment). A wrong or absent byte this method wrote is therefore just a
      * cache MISS on the next read, never a verification bypass.
      */
     async tryStateFastPath(pin, deltaSince, restore) {
-        // gitvault-delta-fetch: carry the caller's MATERIALIZED position as
+        // vault-delta-fetch: carry the caller's MATERIALIZED position as
         // `since` — a capable gateway answers small spans with the heads +
         // inline WAL packs in this same response; every other gateway/span
         // simply omits `delta`. The RESTORE marker (what this git dir has
@@ -2055,7 +2055,7 @@ export class GitvaultVault {
         // that is generations behind — exactly the multi-checkout shape the
         // bench runs.
         //
-        // `restore` (gitvault-restore-recipe design D2/D6) rides the SAME state
+        // `restore` (vault-restore-recipe design D2/D6) rides the SAME state
         // read — never a second round trip — so the caller (`restoreObjectsInto`,
         // via `materialize`/`verifyToNewest`) declares it only on the wholesale
         // shape (see that method's own doc comment). This call declining the
@@ -2067,7 +2067,7 @@ export class GitvaultVault {
         // authenticated pin — checked here regardless of eligibility below, so
         // a regressed vault is caught exactly as loudly as it always was, even
         // when the walk that would otherwise discover it is about to be skipped.
-        checkGenerationRegression(state.newest_generation ?? GITVAULT_GENESIS_GENERATION, pin.generation);
+        checkGenerationRegression(state.newest_generation ?? VAULT_GENESIS_GENERATION, pin.generation);
         // The gateway's own admission ledger advances `newest_generation` to the
         // GENESIS generation (0) the moment genesis itself is admitted — a vault
         // between "genesis admitted" and "first ordinary push" reports its own
@@ -2077,55 +2077,55 @@ export class GitvaultVault {
         // way, "no ORDINARY head yet" is the same case this file has always
         // treated specially: genesis is a DIFFERENT stored-object shape
         // (`vault_genesis` — no `ref_state`/`retention_roots`, {@link
-        // GitvaultVault.genesis} owns verifying it via its OWN cache), so this
-        // path must never parse `state.head` as a {@link GitvaultHead} when it
+        // Vault.genesis} owns verifying it via its OWN cache), so this
+        // path must never parse `state.head` as a {@link VaultHead} when it
         // is actually genesis's bytes.
         if (state.delta)
             this.consumeStateDelta(state.delta);
-        // gitvault-restore-recipe: stashed RAW (never verified here — see the
+        // vault-restore-recipe: stashed RAW (never verified here — see the
         // field's own doc comment); a genesis-only response (below) still runs
         // this line first, but `assembleVaultRestorePlan` never fires server-side
         // before an ordinary head exists, so `state.restore_plan` is simply
         // absent in that window — nothing to stash either way.
         if (state.restore_plan)
             this.stateRestorePlan = state.restore_plan;
-        const noOrdinaryHeadYet = state.newest_generation === null || state.newest_generation === GITVAULT_GENESIS_GENERATION;
+        const noOrdinaryHeadYet = state.newest_generation === null || state.newest_generation === VAULT_GENESIS_GENERATION;
         const pinBig = generationToBigInt(pin.generation);
         const newestBig = noOrdinaryHeadYet ? 0n : generationToBigInt(state.newest_generation);
         const diff = newestBig - pinBig; // ≥ 0n, guaranteed by the regression check above (which treats `null`/genesis identically to this)
         if (diff === 0n) {
             if (noOrdinaryHeadYet)
-                return { entries: [], pinnedHead: null, prevEpoch: GITVAULT_GENESIS_EPOCH }; // matches today's `lastHead = null` for a genesis-only vault
+                return { entries: [], pinnedHead: null, prevEpoch: VAULT_GENESIS_EPOCH }; // matches today's `lastHead = null` for a genesis-only vault
             if (!state.head)
-                fail("CHAIN_BROKEN", "the vault state reports an admitted generation but carries no head bytes", "verifying gitvault chain", { generation: state.newest_generation });
+                fail("CHAIN_BROKEN", "the vault state reports an admitted generation but carries no head bytes", "verifying vault chain", { generation: state.newest_generation });
             const sha = sha256Hex(state.head.stored_bytes);
             if (sha !== pin.head_sha256)
-                fail("CHAIN_BROKEN", `pinned head ${pin.generation} no longer hashes to the pin`, "reading pinned gitvault head", { generation: pin.generation });
+                fail("CHAIN_BROKEN", `pinned head ${pin.generation} no longer hashes to the pin`, "reading pinned vault head", { generation: pin.generation });
             this.keystore.writeCachedHead(this.repoId, pin.generation, sha, state.head.stored_bytes);
-            const head = parseGitvaultStrict(new TextDecoder().decode(state.head.stored_bytes));
+            const head = parseVaultStrict(new TextDecoder().decode(state.head.stored_bytes));
             if (state.carriers)
                 this.warmStateCarrierCache(pin.generation, head, state.carriers);
             return { entries: [], pinnedHead: head, prevEpoch: head.epoch };
         }
         if (diff === 1n) {
             let prevEpoch;
-            if (pin.generation === GITVAULT_GENESIS_GENERATION) {
-                prevEpoch = GITVAULT_GENESIS_EPOCH;
+            if (pin.generation === VAULT_GENESIS_GENERATION) {
+                prevEpoch = VAULT_GENESIS_EPOCH;
             }
             else {
                 const cached = this.keystore.readCachedHead(this.repoId, pin.generation);
                 if (!cached || sha256Hex(cached.bytes) !== pin.head_sha256)
                     return null; // cold cache — decline the shortcut, never weaken it
-                prevEpoch = parseGitvaultStrict(new TextDecoder().decode(cached.bytes)).epoch;
+                prevEpoch = parseVaultStrict(new TextDecoder().decode(cached.bytes)).epoch;
             }
             if (!state.head)
-                fail("CHAIN_BROKEN", "the vault state reports a newer generation but carries no head bytes", "verifying gitvault chain", { generation: state.newest_generation });
+                fail("CHAIN_BROKEN", "the vault state reports a newer generation but carries no head bytes", "verifying vault chain", { generation: state.newest_generation });
             const newestGeneration = state.newest_generation;
             const shaOfBytes = sha256Hex(state.head.stored_bytes);
             if (shaOfBytes !== state.head.stored_bytes_sha256)
                 fail("CHAIN_BROKEN", `head ${newestGeneration}: stored bytes hash does not match its own declared hash`, "verifying head chain", { generation: newestGeneration });
             this.keystore.writeCachedHead(this.repoId, newestGeneration, shaOfBytes, state.head.stored_bytes);
-            const head = parseGitvaultStrict(new TextDecoder().decode(state.head.stored_bytes));
+            const head = parseVaultStrict(new TextDecoder().decode(state.head.stored_bytes));
             if (state.carriers)
                 this.warmStateCarrierCache(newestGeneration, head, state.carriers);
             // `pinnedHead` is a throwaway — see this method's own doc comment: the
@@ -2136,7 +2136,7 @@ export class GitvaultVault {
         return null; // more than one generation behind — the existing listHeads walk owns this
     }
     /**
-     * Absorb a state read's delta (gitvault-delta-fetch): heads blind-warm the
+     * Absorb a state read's delta (vault-delta-fetch): heads blind-warm the
      * SAME keystore head cache every walk already re-verifies on read (the
      * established cache discipline — a wrong byte is a miss, never a bypass),
      * gated only on each entry's self-consistency; packs stash into the
@@ -2199,7 +2199,7 @@ export class GitvaultVault {
      * producer/consumer would, and counting each decrypt attempt as an EXTRA
      * unit against the same `this.budget` (decryption is the expensive step).
      * `options.strict` (default `true`) throws immediately, fail-closed, on the
-     * first `GITVAULT_EPOCH_NOT_OPENABLE` / AEAD failure it hits — the ordinary
+     * first `VAULT_EPOCH_NOT_OPENABLE` / AEAD failure it hits — the ordinary
      * `materialize()` read path's behavior. `strict: false` (fsck's tolerant
      * mode) instead records `decrypt.failure` and stops attempting further
      * decrypts while the pure chain walk keeps going — this is exactly what
@@ -2211,7 +2211,7 @@ export class GitvaultVault {
         const decryptValidate = options.decryptValidate ?? false;
         const strict = options.strict ?? true;
         const { genesis, sha256: genesisSha } = await this.genesis();
-        // gitvault-multi-writer rev 47: `writerKey`/`writerKeyId` (kept for the
+        // vault-multi-writer rev 47: `writerKey`/`writerKeyId` (kept for the
         // rotation-envelope open below, which is signed by whoever DROVE that
         // specific rotation — resolved per-rotation from `writerState`, not this
         // fallback) name just the genesis creator, retained as the seed for
@@ -2220,12 +2220,12 @@ export class GitvaultVault {
         const writerKey = genesis.creator_signing_pubkey;
         const writerKeyId = genesis.writer_key_id;
         const repo = this.repoFile();
-        let pin = repo.verified_prefix ?? repo.head_pin ?? { generation: GITVAULT_GENESIS_GENERATION, head_sha256: genesisSha, pinned_at: formatGitvaultTimestamp(this.now()) };
-        // gitvault-multi-writer rev 47 (task 5.1): the writer set as chain state.
+        let pin = repo.verified_prefix ?? repo.head_pin ?? { generation: VAULT_GENESIS_GENERATION, head_sha256: genesisSha, pinned_at: formatVaultTimestamp(this.now()) };
+        // vault-multi-writer rev 47 (task 5.1): the writer set as chain state.
         // Trusted as the starting point at `pin`'s generation exactly the same
         // way `pin` itself is trusted as the starting point for the head chain —
         // `writer_set_pin` advances in LOCKSTEP with `head_pin`/`verified_prefix`
-        // (see `GitvaultRepoFile.writer_set_pin`'s own doc comment), so a repeat
+        // (see `VaultRepoFile.writer_set_pin`'s own doc comment), so a repeat
         // call never re-walks the writer set from genesis. `initialWriterState`
         // covers the true first-ever call (no persisted pin yet).
         //
@@ -2251,38 +2251,38 @@ export class GitvaultVault {
         // the complete bookkeeping.
         const legacyWriterPin = repo.writer_set_pin != null && repo.writer_set_pin.retired_writers === undefined;
         if (legacyWriterPin)
-            pin = { generation: GITVAULT_GENESIS_GENERATION, head_sha256: genesisSha, pinned_at: formatGitvaultTimestamp(this.now()) };
+            pin = { generation: VAULT_GENESIS_GENERATION, head_sha256: genesisSha, pinned_at: formatVaultTimestamp(this.now()) };
         let writerState = repo.writer_set_pin && !legacyWriterPin
             ? { version: repo.writer_set_pin.version, writers: repo.writer_set_pin.writers, sha256: repo.writer_set_pin.sha256, burnedWriterKeyIds: new Set(), consumedHandoffIds: new Set(), retiredWriters: repo.writer_set_pin.retired_writers ?? [] }
             : initialWriterState(this.repoId, genesis);
         const persistWriterSetPin = () => {
             if (!persist)
                 return;
-            this.keystore.updateRepo(this.repoId, { writer_set_pin: { version: writerState.version, sha256: writerState.sha256, writers: [...writerState.writers], retired_writers: [...(writerState.retiredWriters ?? [])], pinned_at: formatGitvaultTimestamp(this.now()) } });
+            this.keystore.updateRepo(this.repoId, { writer_set_pin: { version: writerState.version, sha256: writerState.sha256, writers: [...writerState.writers], retired_writers: [...(writerState.retiredWriters ?? [])], pinned_at: formatVaultTimestamp(this.now()) } });
         };
-        // gitvault-composite-state-read design D1: try the pin-current fast path
+        // vault-composite-state-read design D1: try the pin-current fast path
         // FIRST — see {@link tryStateFastPath}'s own doc comment. `null` means
         // ineligible (genuinely more than one generation behind, or the pin's
         // own epoch could not be resolved without the network read this path
         // exists to avoid) — the caller falls straight through to the UNCHANGED
         // readHead + listHeads flow below, byte-identical to before this change.
-        // `options.restore` (gitvault-restore-recipe) rides along unchanged —
+        // `options.restore` (vault-restore-recipe) rides along unchanged —
         // declined exactly when the fast path itself is declined, so a caller
         // more than one generation behind never gets (or needs) a plan here.
         const fastPath = await this.tryStateFastPath(pin, options.deltaSince, options.restore);
-        let lastHead = fastPath ? fastPath.pinnedHead : pin.generation === GITVAULT_GENESIS_GENERATION ? null : await this.readHead(pin.generation, pin.head_sha256);
+        let lastHead = fastPath ? fastPath.pinnedHead : pin.generation === VAULT_GENESIS_GENERATION ? null : await this.readHead(pin.generation, pin.head_sha256);
         const anchor = pin.generation;
-        let prevEpoch = fastPath ? fastPath.prevEpoch : (lastHead?.epoch ?? GITVAULT_GENESIS_EPOCH);
+        let prevEpoch = fastPath ? fastPath.prevEpoch : (lastHead?.epoch ?? VAULT_GENESIS_EPOCH);
         let progress = { after_generation: anchor, last_generation: anchor, delivered: 0 };
-        let request = { after_generation: anchor, limit: String(GITVAULT_MAX_HEADS_PER_LISTING_PAGE) };
+        let request = { after_generation: anchor, limit: String(VAULT_MAX_HEADS_PER_LISTING_PAGE) };
         let verified = 0;
         const rotations = [];
-        // gitvault-clone-scaling (P3): coverage this walk LEARNS. A checkpoint
+        // vault-clone-scaling (P3): coverage this walk LEARNS. A checkpoint
         // head names it outright; a walk anchored at GENESIS that completes
         // without seeing one proves coverage = genesis. A partial (non-genesis)
         // walk that sees none proves nothing and persists nothing.
         let walkCheckpointCoverage = null;
-        const walkedFromGenesis = anchor === GITVAULT_GENESIS_GENERATION;
+        const walkedFromGenesis = anchor === VAULT_GENESIS_GENERATION;
         // Consumed by (at most) the FIRST for(;;) iteration below — a listHeads
         // page this call never had to ask the network for, because the state
         // read above already proved it (0 entries: pin already current; 1 entry:
@@ -2335,7 +2335,7 @@ export class GitvaultVault {
                         continue;
                     current = { generation: rot.generation, epoch: rot.epoch, rotation_id: rot.payload.rotation_id };
                     if (!identity || !ownKeypair) {
-                        fail("GITVAULT_EPOCH_NOT_OPENABLE", `no local gitvault identity — cannot open epoch ${rot.epoch} (rotation ${rot.payload.rotation_id})`, "opening an epoch-rotation key envelope", { epoch: rot.epoch, rotation_id: rot.payload.rotation_id });
+                        fail("VAULT_EPOCH_NOT_OPENABLE", `no local vault identity — cannot open epoch ${rot.epoch} (rotation ${rot.payload.rotation_id})`, "opening an epoch-rotation key envelope", { epoch: rot.epoch, rotation_id: rot.payload.rotation_id });
                     }
                     const ownFingerprint = ekFingerprint(ownKeypair.public_key);
                     const kE = await openEpochRotationForRecipient({
@@ -2343,13 +2343,13 @@ export class GitvaultVault {
                         payload: rot.payload,
                         own_fingerprint: ownFingerprint,
                         own_encryption_keypair: ownKeypair,
-                        // gitvault-multi-writer rev 47: the writer who actually drove
+                        // vault-multi-writer rev 47: the writer who actually drove
                         // THIS rotation (resolved by the forward walk when it collected
-                        // `rot` — see `GitvaultEncounteredRotation.signing_pubkey`'s own
+                        // `rot` — see `VaultEncounteredRotation.signing_pubkey`'s own
                         // doc comment for the one narrower gap this falls back for).
                         writer_signing_public_key: rot.signing_pubkey ?? writerKey,
                         get_envelope_bytes: (path) => this.transport.getObject({ repo_id: this.repoId, path }),
-                        envelope_path: (epoch, fp, rotationId) => gitvaultPaths.envelope(epoch, fp, rotationId),
+                        envelope_path: (epoch, fp, rotationId) => vaultPaths.envelope(epoch, fp, rotationId),
                     });
                     epochKeys[rot.epoch] = bytesToHex(kE);
                     if (persist)
@@ -2358,29 +2358,29 @@ export class GitvaultVault {
                 current = { generation: head.generation, epoch: head.epoch, rotation_id: null };
                 const kRepoHex = epochKeys[head.epoch];
                 if (!kRepoHex) {
-                    fail("GITVAULT_EPOCH_NOT_OPENABLE", `no locally known key for epoch ${head.epoch} at generation ${head.generation}`, "materializing gitvault head", { epoch: head.epoch, generation: head.generation });
+                    fail("VAULT_EPOCH_NOT_OPENABLE", `no locally known key for epoch ${head.epoch} at generation ${head.generation}`, "materializing vault head", { epoch: head.epoch, generation: head.generation });
                 }
                 const kRepo = hexToBytes(kRepoHex);
                 // Design D2: ref_state + retention_roots both ride `head`, so one
                 // batched presign (or a cache hit) serves both instead of two
                 // independent presign-then-GET round trips.
-                // gitvault-multi-writer rev 47: `head`'s OWN signer, resolved from
+                // vault-multi-writer rev 47: `head`'s OWN signer, resolved from
                 // the writer state — by the time this runs, `writerState` already
                 // reflects `head`'s own transition (if any), so this correctly finds
                 // a just-self-admitted handoff writer too, not only a pre-existing one.
                 // Historical read: the head is already admitted, so a writer removed
                 // SINCE it was signed still verifies it (retired keys are kept).
                 const headSigner = resolveKnownWriter(writerState, head.writer_key_id)?.signing_pubkey ?? writerKey;
-                const { refState, roots } = await this.openMaterializeCarriers(head.ref_state, gitvaultPaths.refState(head.ref_state.object_id), head.retention_roots, gitvaultPaths.retentionRoots(head.retention_roots.object_id), headSigner, { epoch: head.epoch, k_repo: kRepo });
+                const { refState, roots } = await this.openMaterializeCarriers(head.ref_state, vaultPaths.refState(head.ref_state.object_id), head.retention_roots, vaultPaths.retentionRoots(head.retention_roots.object_id), headSigner, { epoch: head.epoch, k_repo: kRepo });
                 if (refState.generation !== head.generation || roots.generation !== head.generation)
-                    fail("CHAIN_UNUSABLE", "carrier generation does not match the head", "materializing gitvault head");
+                    fail("CHAIN_UNUSABLE", "carrier generation does not match the head", "materializing vault head");
                 decryptedRefState = refState;
                 decryptedRoots = roots;
                 decryptPin = { ...headPin };
                 return true;
             }
             catch (e) {
-                const code = isRun402Error(e) && e.code ? e.code : "GITVAULT_EPOCH_NOT_OPENABLE";
+                const code = isRun402Error(e) && e.code ? e.code : "VAULT_EPOCH_NOT_OPENABLE";
                 decryptFailure = { generation: current.generation, epoch: current.epoch, rotation_id: current.rotation_id, code, message: e instanceof Error ? e.message : String(e) };
                 decryptFailureError = e;
                 return false;
@@ -2392,11 +2392,11 @@ export class GitvaultVault {
             // the loop right after it is consumed, so clearing it here is purely
             // defensive (a real second iteration can never see it non-null).
             const page = syntheticEntries !== null
-                ? { format: GITVAULT_FORMAT, repo_id: this.repoId, after_generation: request.after_generation, heads: syntheticEntries, has_more: false, next_cursor: null, total: null }
+                ? { format: VAULT_FORMAT, repo_id: this.repoId, after_generation: request.after_generation, heads: syntheticEntries, has_more: false, next_cursor: null, total: null }
                 : await this.transport.listHeads({ repo_id: this.repoId, ...request });
             syntheticEntries = null;
             progress = verifyHeadsListingPage(page, request, progress, this.repoId);
-            // gitvault-clone-scaling (bench P2): the page just verified names every
+            // vault-clone-scaling (bench P2): the page just verified names every
             // entry's generation + stored_bytes_sha256, and the BYTES reads are
             // independent — verification (and decryption) order is a LOCAL
             // obligation. Bounded by the remaining verification budget, this
@@ -2428,7 +2428,7 @@ export class GitvaultVault {
                     if (missingHeads.length > 1) {
                         const fetched = await this.prefetchHeadsConcurrent(missingHeads.map((e) => e.generation));
                         for (const e of missingHeads) {
-                            const path = gitvaultPaths.head(e.generation);
+                            const path = vaultPaths.head(e.generation);
                             const bytes = fetched.get(path) ?? null;
                             if (bytes && sha256Hex(bytes) === e.stored_bytes_sha256)
                                 prefetch.set(path, bytes);
@@ -2437,19 +2437,19 @@ export class GitvaultVault {
                     if (decryptValidate && wanted.length > 1) {
                         const carriers = [];
                         for (const e of wanted) {
-                            const headBytes = prefetch.get(gitvaultPaths.head(e.generation)) ?? cachedHeadIfMatching(e);
+                            const headBytes = prefetch.get(vaultPaths.head(e.generation)) ?? cachedHeadIfMatching(e);
                             if (!headBytes)
                                 continue;
                             let parsed;
                             try {
-                                parsed = parseGitvaultStrict(new TextDecoder().decode(headBytes));
+                                parsed = parseVaultStrict(new TextDecoder().decode(headBytes));
                             }
                             catch {
                                 continue; // the ordered loop's checkChainLink owns rejecting it
                             }
                             for (const w of [
-                                { receipt: parsed.ref_state, path: gitvaultPaths.refState(parsed.ref_state.object_id) },
-                                { receipt: parsed.retention_roots, path: gitvaultPaths.retentionRoots(parsed.retention_roots.object_id) },
+                                { receipt: parsed.ref_state, path: vaultPaths.refState(parsed.ref_state.object_id) },
+                                { receipt: parsed.retention_roots, path: vaultPaths.retentionRoots(parsed.retention_roots.object_id) },
                             ]) {
                                 const cached = this.keystore.readCachedCarrier(this.repoId, w.receipt.object_id);
                                 if (cached && sha256Hex(cached.bytes) === w.receipt.ciphertext_sha256)
@@ -2482,13 +2482,13 @@ export class GitvaultVault {
                     persistMaterializedIfAny();
                     fail("VERIFICATION_BUDGET_EXCEEDED", persist
                         ? `${verified} heads verified this call; the verified prefix (generation ${pin.generation}) is persisted — call again to continue`
-                        : `${verified} heads verified this call in no-write mode; nothing was persisted — a retry restarts from the original pin, not generation ${pin.generation}`, "verifying gitvault chain", { verified_through: pin.generation, persisted: persist }, [{ action: persist ? "resume verification from the persisted verified prefix" : "re-run without --no-write to persist and resume incrementally, or re-run this same audit call again from the start" }]);
+                        : `${verified} heads verified this call in no-write mode; nothing was persisted — a retry restarts from the original pin, not generation ${pin.generation}`, "verifying vault chain", { verified_through: pin.generation, persisted: persist }, [{ action: persist ? "resume verification from the persisted verified prefix" : "re-run without --no-write to persist and resume incrementally, or re-run this same audit call again from the start" }]);
                 }
                 const bytes = await this.readCachedHeadBytes(entry.generation, entry.stored_bytes_sha256);
                 if (!bytes)
-                    fail("CHAIN_BROKEN", `listed head ${entry.generation} is absent from storage`, "verifying gitvault chain", { generation: entry.generation });
-                const head = parseGitvaultStrict(new TextDecoder().decode(bytes));
-                // gitvault-multi-writer rev 47 (task 5.1): resolve WHO must have
+                    fail("CHAIN_BROKEN", `listed head ${entry.generation} is absent from storage`, "verifying vault chain", { generation: entry.generation });
+                const head = parseVaultStrict(new TextDecoder().decode(bytes));
+                // vault-multi-writer rev 47 (task 5.1): resolve WHO must have
                 // signed this specific head from the writer state as of the
                 // PREDECESSOR generation (`writerState`, not yet advanced past this
                 // head) — never the single fixed genesis key. A head carrying an
@@ -2504,7 +2504,7 @@ export class GitvaultVault {
                         this.keystore.updateRepo(this.repoId, { head_pin: pin, verified_prefix: null });
                     persistWriterSetPin();
                     persistMaterializedIfAny();
-                    fail(code, `head ${head.generation}: ${detail}`, "verifying gitvault chain", { generation: head.generation });
+                    fail(code, `head ${head.generation}: ${detail}`, "verifying vault chain", { generation: head.generation });
                 };
                 const isWriterAdd = head.transition !== null && head.transition.kind === "add_writer_key";
                 let addWriterKeyPayload = null;
@@ -2530,7 +2530,7 @@ export class GitvaultVault {
                 else {
                     const signer = resolveActiveWriter(writerState, head.writer_key_id);
                     if (!signer)
-                        failClosedTransition("GITVAULT_WRITER_NOT_ADMITTED", `writer_key_id ${head.writer_key_id} is not a currently admitted writer`);
+                        failClosedTransition("VAULT_WRITER_NOT_ADMITTED", `writer_key_id ${head.writer_key_id} is not a currently admitted writer`);
                     resolvedWriterPubkey = signer.signing_pubkey;
                     resolvedWriterKeyId = signer.writer_key_id;
                 }
@@ -2556,7 +2556,7 @@ export class GitvaultVault {
                     // can still resolve the epoch keys it needs.
                     rotationPayload = parseRotateEpochPayload(head);
                     rotations.push({ generation: head.generation, epoch: head.epoch, payload: rotationPayload, signing_pubkey: resolvedWriterPubkey });
-                    // gitvault-multi-writer rev 47 (D227): writer REMOVAL rides
+                    // vault-multi-writer rev 47 (D227): writer REMOVAL rides
                     // rotate_epoch as an additive `writer_set_update` field. The
                     // "blocked set" gate inside `validateWriterSetUpdate` is a
                     // gateway-only, live-state fact this reader cannot independently
@@ -2584,7 +2584,7 @@ export class GitvaultVault {
                     writerState = applyAddWriterKey(this.repoId, writerState, { writer_key_id: addWriterKeyPayload.added_writer.writer_key_id, signing_pubkey: addWriterKeyPayload.added_writer.signing_pubkey }, consumedHandoffId);
                 }
                 prevEpoch = head.epoch;
-                pin = { generation: head.generation, head_sha256: entry.stored_bytes_sha256, pinned_at: formatGitvaultTimestamp(this.now()) };
+                pin = { generation: head.generation, head_sha256: entry.stored_bytes_sha256, pinned_at: formatVaultTimestamp(this.now()) };
                 lastHead = head;
                 if (head.checkpoint)
                     walkCheckpointCoverage = head.checkpoint.covers_through_generation;
@@ -2615,7 +2615,7 @@ export class GitvaultVault {
         // is authoritative for its whole history, so no checkpoint seen means
         // coverage = genesis, honestly.
         if (persist) {
-            const learned = walkCheckpointCoverage ?? (walkedFromGenesis ? GITVAULT_GENESIS_GENERATION : null);
+            const learned = walkCheckpointCoverage ?? (walkedFromGenesis ? VAULT_GENESIS_GENERATION : null);
             if (learned !== null)
                 this.keystore.updateRepo(this.repoId, { checkpoint_covers_through: learned });
         }
@@ -2639,7 +2639,7 @@ export class GitvaultVault {
             while (cur && !epochKeys[cur.epoch]) {
                 if (cur.transition !== null && cur.transition.kind === "rotate_epoch") {
                     const payload = parseRotateEpochPayload(cur);
-                    // gitvault-multi-writer rev 47: best-effort resolution against the
+                    // vault-multi-writer rev 47: best-effort resolution against the
                     // FINAL (post-forward-walk) writer state — correct unless `cur`'s
                     // own signer was removed by a LATER rotation between `cur` and
                     // `lastHead`, the one documented residual gap (falls back to the
@@ -2661,9 +2661,9 @@ export class GitvaultVault {
                 // {@link readCachedHeadBytes} documents, so a cache hit is safe here too.
                 const bytes = await this.readCachedHeadBytes(prevGen, cur.prev_sha256);
                 if (!bytes || sha256Hex(bytes) !== cur.prev_sha256)
-                    fail("CHAIN_BROKEN", `head ${prevGen} does not match the chain during epoch-key catch-up`, "materializing gitvault head", { generation: prevGen });
-                cur = parseGitvaultStrict(new TextDecoder().decode(bytes));
-                curPin = { generation: prevGen, head_sha256: bytes ? sha256Hex(bytes) : curPin.head_sha256, pinned_at: formatGitvaultTimestamp(this.now()) };
+                    fail("CHAIN_BROKEN", `head ${prevGen} does not match the chain during epoch-key catch-up`, "materializing vault head", { generation: prevGen });
+                cur = parseVaultStrict(new TextDecoder().decode(bytes));
+                curPin = { generation: prevGen, head_sha256: bytes ? sha256Hex(bytes) : curPin.head_sha256, pinned_at: formatVaultTimestamp(this.now()) };
             }
             rotations.sort((a, b) => (a.generation < b.generation ? -1 : a.generation > b.generation ? 1 : 0));
             // `cur` (non-null, non-lastHead) is the BOUNDARY generation whose own
@@ -2698,7 +2698,7 @@ export class GitvaultVault {
             rotations,
             decrypt: decryptValidate
                 ? {
-                    decryptable_to_generation: decryptPin?.generation ?? GITVAULT_GENESIS_GENERATION,
+                    decryptable_to_generation: decryptPin?.generation ?? VAULT_GENESIS_GENERATION,
                     ref_state: decryptedRefState,
                     retention_roots: decryptedRoots,
                     epoch_keys_hex: epochKeys,
@@ -2728,10 +2728,10 @@ export class GitvaultVault {
         const cached = this.keystore.readCachedHead(this.repoId, generation);
         if (cached && sha256Hex(cached.bytes) === expectedSha256)
             return cached.bytes;
-        // gitvault-clone-scaling (P2): a page-prefetched head serves exactly as
+        // vault-clone-scaling (P2): a page-prefetched head serves exactly as
         // a network fetch would — sha-checked here against the SAME expected
         // value, then cache-warmed. A miss/mismatch falls through to the read.
-        const path = gitvaultPaths.head(generation);
+        const path = vaultPaths.head(generation);
         const prefetched = this.walkPrefetch?.get(path);
         if (prefetched && sha256Hex(prefetched) === expectedSha256) {
             this.keystore.writeCachedHead(this.repoId, generation, expectedSha256, prefetched);
@@ -2752,18 +2752,18 @@ export class GitvaultVault {
      * THIS call's own read is exempt.
      */
     async readHead(generation, expectedSha256) {
-        const bytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.head(generation) });
+        const bytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.head(generation) });
         // Absent ⇒ the vault no longer holds a generation this client authenticated: a ROLLBACK, not a
         // broken link (chain-005). Present-but-different bytes IS a broken link (substituted object).
         if (!bytes) {
-            fail("GENERATION_REGRESSION", `the vault no longer holds the authenticated generation ${generation}; it regressed below the pin`, "reading pinned gitvault head", { generation }, [
+            fail("GENERATION_REGRESSION", `the vault no longer holds the authenticated generation ${generation}; it regressed below the pin`, "reading pinned vault head", { generation }, [
                 { action: "do not publish; escalate — the vault regressed below a generation this client authenticated" },
             ]);
         }
         if (sha256Hex(bytes) !== expectedSha256)
-            fail("CHAIN_BROKEN", `pinned head ${generation} no longer hashes to the pin`, "reading pinned gitvault head", { generation });
+            fail("CHAIN_BROKEN", `pinned head ${generation} no longer hashes to the pin`, "reading pinned vault head", { generation });
         this.keystore.writeCachedHead(this.repoId, generation, expectedSha256, bytes);
-        return parseGitvaultStrict(new TextDecoder().decode(bytes));
+        return parseVaultStrict(new TextDecoder().decode(bytes));
     }
     /**
      * Decrypt + verify one carrier's already-fetched ciphertext frame; any
@@ -2782,17 +2782,17 @@ export class GitvaultVault {
         const epoch = keyOverride?.epoch ?? this.epoch();
         const kRepo = keyOverride?.k_repo ?? this.kRepo();
         if (!frame)
-            fail("CHAIN_UNUSABLE", `${kind} ${receipt.object_id} is absent from storage`, "materializing gitvault head", { object_id: receipt.object_id }, [{ action: "stay read-only at the materialized pin; run the repair path" }]);
+            fail("CHAIN_UNUSABLE", `${kind} ${receipt.object_id} is absent from storage`, "materializing vault head", { object_id: receipt.object_id }, [{ action: "stay read-only at the materialized pin; run the repair path" }]);
         let plaintext;
         try {
             plaintext = openFrame({ k_obj: deriveObjectKey(kRepo, this.repoId, epoch, kind, receipt.object_id), repo_id: this.repoId, object_kind: kind, object_id: receipt.object_id, epoch, frame, expected_ciphertext_sha256: receipt.ciphertext_sha256 });
         }
         catch (e) {
-            fail("CHAIN_UNUSABLE", `${kind} ${receipt.object_id} cannot be opened: ${e.message}`, "materializing gitvault head", { object_id: receipt.object_id }, [{ action: "stay read-only at the materialized pin; run the repair path" }]);
+            fail("CHAIN_UNUSABLE", `${kind} ${receipt.object_id} cannot be opened: ${e.message}`, "materializing vault head", { object_id: receipt.object_id }, [{ action: "stay read-only at the materialized pin; run the repair path" }]);
         }
-        const object = parseGitvaultStrict(new TextDecoder().decode(plaintext));
-        if (object.object_kind !== kind || object.object_id !== receipt.object_id || object.repo_id !== this.repoId || !verifyGitvaultObject(object, writerKey)) {
-            fail("CHAIN_UNUSABLE", `${kind} ${receipt.object_id} plaintext fails its identity/signature checks`, "materializing gitvault head", { object_id: receipt.object_id });
+        const object = parseVaultStrict(new TextDecoder().decode(plaintext));
+        if (object.object_kind !== kind || object.object_id !== receipt.object_id || object.repo_id !== this.repoId || !verifyVaultObject(object, writerKey)) {
+            fail("CHAIN_UNUSABLE", `${kind} ${receipt.object_id} plaintext fails its identity/signature checks`, "materializing vault head", { object_id: receipt.object_id });
         }
         return object;
     }
@@ -2832,7 +2832,7 @@ export class GitvaultVault {
         const cachedRoots = this.keystore.readCachedCarrier(this.repoId, rootsReceipt.object_id);
         const refStateHit = Boolean(cachedRefState && sha256Hex(cachedRefState.bytes) === refStateReceipt.ciphertext_sha256);
         const rootsHit = Boolean(cachedRoots && sha256Hex(cachedRoots.bytes) === rootsReceipt.ciphertext_sha256);
-        // gitvault-clone-scaling (P2): a page-prefetched frame serves exactly as
+        // vault-clone-scaling (P2): a page-prefetched frame serves exactly as
         // a fetched one — sha-checked against the receipt's ciphertext hash; a
         // miss/mismatch falls through to the batched network read below.
         const preRefState = !refStateHit ? (this.walkPrefetch?.get(refStatePath) ?? null) : null;
@@ -2873,7 +2873,7 @@ export class GitvaultVault {
      * transition now opens the rotation's own envelope and decrypts under the
      * NEW epoch, chaining through multiple sequential rotations; a keystore
      * with no envelope for a new epoch fails CLOSED with
-     * `GITVAULT_EPOCH_NOT_OPENABLE`, never a bare `GITVAULT_AEAD_AUTH_FAILURE`)
+     * `VAULT_EPOCH_NOT_OPENABLE`, never a bare `VAULT_AEAD_AUTH_FAILURE`)
      * — `strict: true` means this call throws exactly where the OLD
      * (pre-fix) `materialize()` silently produced a wrong `k_obj` instead.
      */
@@ -2882,7 +2882,7 @@ export class GitvaultVault {
         const state = await this.verifyToNewest({ persist, decryptValidate: true, strict: true, deltaSince: options.deltaSince, restore: options.restore });
         if (!state.head) {
             if (persist)
-                this.keystore.updateRepo(this.repoId, { materialized_pin: { generation: state.generation, head_sha256: state.head_sha256, pinned_at: formatGitvaultTimestamp(this.now()) } });
+                this.keystore.updateRepo(this.repoId, { materialized_pin: { generation: state.generation, head_sha256: state.head_sha256, pinned_at: formatVaultTimestamp(this.now()) } });
             return { ...state, ref_state: null, retention_roots: null, refs: {}, roots: [], head_target: { kind: "symref", ref: "refs/heads/main" }, epoch_keys_hex: state.decrypt?.epoch_keys_hex ?? {} };
         }
         // `strict: true` guarantees `state.decrypt` is non-null with no failure
@@ -2894,10 +2894,10 @@ export class GitvaultVault {
         const refState = state.decrypt.ref_state;
         const roots = state.decrypt.retention_roots;
         if (refState.generation !== state.generation || roots.generation !== state.generation)
-            fail("CHAIN_UNUSABLE", "carrier generation does not match the head", "materializing gitvault head");
+            fail("CHAIN_UNUSABLE", "carrier generation does not match the head", "materializing vault head");
         return { ...state, ref_state: refState, retention_roots: roots, refs: { ...refState.refs }, roots: roots.roots.map((r) => ({ ...r })), head_target: refState.head_target, epoch_keys_hex: state.decrypt.epoch_keys_hex };
     }
-    // ── envelope recipients (gitvault-human-envelopes task 4.1, the ADD-path workaround) ──
+    // ── envelope recipients (vault-human-envelopes task 4.1, the ADD-path workaround) ──
     /**
      * Wrap the vault's CURRENT epoch key to every org member the directory
      * lists but the vault does not yet have a `key_envelope` for.
@@ -2906,7 +2906,7 @@ export class GitvaultVault {
      * describes a recipient-set change as an epoch rotation — "history epochs
      * stay wrapped as they were; a new member reads from their first covered
      * epoch forward" — which needs a protocol revision: V0 pins `epoch` to
-     * the single constant `GITVAULT_GENESIS_EPOCH` on every head, so there
+     * the single constant `VAULT_GENESIS_EPOCH` on every head, so there
      * is no "forward" to speak of. What this method actually does, legally, without any
      * protocol change: `key_envelope` objects are never head-referenced (not
      * even genesis's own envelope is), so uploading an ADDITIONAL one at
@@ -2931,7 +2931,7 @@ export class GitvaultVault {
      *
      * **The gateway directory route carries `public_key` on every row**
      * (`GET /orgs/v1/:org_id/encryption-keys` — see the
-     * doc comment on {@link GitvaultOrgEncryptionKeyEntry}), so against a
+     * doc comment on {@link VaultOrgEncryptionKeyEntry}), so against a
      * current gateway entries actually wrap. A directory entry that arrives
      * WITHOUT the field (an older/rolling-deploy gateway) is still tolerated
      * per-entry — reported under `skipped` with reason `missing_public_key`,
@@ -2939,9 +2939,9 @@ export class GitvaultVault {
      *
      * Best-effort by design at the call site, not here: this method itself
      * either completes (returning a full per-recipient breakdown) or throws
-     * (e.g. `GITVAULT_READ_ONLY` when this principal holds no signing key).
+     * (e.g. `VAULT_READ_ONLY` when this principal holds no signing key).
      * Callers that want "never block on this" (the deploy hook) wrap the call
-     * themselves — see `Gitvault.push`'s `#tryReconcileEnvelopeRecipients`.
+     * themselves — see `Repos.capture`'s `#tryReconcileEnvelopeRecipients`.
      */
     async reconcileEnvelopeRecipients() {
         const repo = this.repoFile();
@@ -2996,13 +2996,13 @@ export class GitvaultVault {
                 epoch,
                 recipient_public_key: recipientPublicKey,
                 signer,
-                created_at: formatGitvaultTimestamp(this.now()),
+                created_at: formatVaultTimestamp(this.now()),
             });
             try {
                 const byo = await this.resolveByoWriteTarget();
                 await this.transport.putObject({
                     repo_id: this.repoId,
-                    path: gitvaultPaths.envelope(epoch, sealed.receipt.recipient_fingerprint),
+                    path: vaultPaths.envelope(epoch, sealed.receipt.recipient_fingerprint),
                     bytes: sealed.stored_bytes,
                     expected_sha256: sealed.stored_bytes_sha256,
                     expected_size_bytes: sealed.size_bytes,
@@ -3015,25 +3015,25 @@ export class GitvaultVault {
                 // the SAME recipient first — HPKE seal is randomized, so two valid
                 // wraps of the same K_repo to the same recipient produce DIFFERENT
                 // ciphertext bytes, and the create-only path's read-and-compare
-                // reports that as `GITVAULT_OBJECT_EXISTS_DIFFERENT` even though the
+                // reports that as `VAULT_OBJECT_EXISTS_DIFFERENT` even though the
                 // recipient is now genuinely covered. Treat exactly that code as a
                 // benign race, not a failure; anything else propagates.
-                if (isRun402Error(e) && e.code === "GITVAULT_OBJECT_EXISTS_DIFFERENT") {
-                    // gitvault-agent-envelopes (consult 7.6): a benign race is only
+                if (isRun402Error(e) && e.code === "VAULT_OBJECT_EXISTS_DIFFERENT") {
+                    // vault-agent-envelopes (consult 7.6): a benign race is only
                     // benign once the WINNING envelope has been read back and verified
                     // — same repo, same epoch, this recipient, signed by the vault's
                     // registered writer. Anything else is recorded as skipped, never as
                     // coverage, and never pinned.
-                    const winnerPath = gitvaultPaths.envelope(epoch, sealed.receipt.recipient_fingerprint);
+                    const winnerPath = vaultPaths.envelope(epoch, sealed.receipt.recipient_fingerprint);
                     const winnerBytes = await this.transport.getObject({ repo_id: this.repoId, path: winnerPath }).catch(() => null);
                     let winnerOk = false;
                     if (winnerBytes) {
                         try {
-                            const winner = parseGitvaultStrict(new TextDecoder().decode(winnerBytes));
+                            const winner = parseVaultStrict(new TextDecoder().decode(winnerBytes));
                             const g = (await this.genesis()).genesis;
                             winnerOk = winner.repo_id === this.repoId && winner.epoch === epoch && winner.recipient_fingerprint === entry.ek_fingerprint
                                 && winner.created_by === g.writer_key_id
-                                && verifyGitvaultObject(winner, g.creator_signing_pubkey);
+                                && verifyVaultObject(winner, g.creator_signing_pubkey);
                         }
                         catch {
                             winnerOk = false;
@@ -3044,7 +3044,7 @@ export class GitvaultVault {
                         // winner does not verify is evidence of tampering, equivocation,
                         // or broken object identity — categorically different from a
                         // stale recipient. FATAL, never an ordinary skip.
-                        fail("GITVAULT_ENVELOPE_ALTERED", `a conflicting key_envelope already stored at ${winnerPath} does not verify as this vault's writer-signed envelope for this recipient — refusing to treat the conflict as a benign race`, "reconciling gitvault envelope recipients", { repo_id: this.repoId, path: winnerPath, epoch, recipient_fingerprint: entry.ek_fingerprint });
+                        fail("VAULT_ENVELOPE_ALTERED", `a conflicting key_envelope already stored at ${winnerPath} does not verify as this vault's writer-signed envelope for this recipient — refusing to treat the conflict as a benign race`, "reconciling vault envelope recipients", { repo_id: this.repoId, path: winnerPath, epoch, recipient_fingerprint: entry.ek_fingerprint });
                     }
                     alreadyCovered.push(entry.ek_fingerprint);
                 }
@@ -3074,7 +3074,7 @@ export class GitvaultVault {
         return { path, object_kind: kind, object_id: objectId, bytes: sealed.frame, sha256: sealed.ciphertext_sha256, size_bytes: sealed.size_bytes };
     }
     /**
-     * The owner signing seed, or `GITVAULT_READ_ONLY`.
+     * The owner signing seed, or `VAULT_READ_ONLY`.
      *
      * Public so the prune lane signs its intent core, wrapper, and verifier
      * receipt through the SAME refusal path every other signed object uses — a
@@ -3086,12 +3086,12 @@ export class GitvaultVault {
         const identity = this.keystore.ensureIdentity();
         const kp = this.keystore.signingKeypair(identity);
         if (!kp)
-            fail("GITVAULT_READ_ONLY", "the signing key is missing from identity.json; this principal is read-only", "signing gitvault object", undefined, [{ action: "stay read-only at the materialized pin" }]);
+            fail("VAULT_READ_ONLY", "the signing key is missing from identity.json; this principal is read-only", "signing vault object", undefined, [{ action: "stay read-only at the materialized pin" }]);
         return kp.seed;
     }
     writerKeyId() { return this.keystore.ensureIdentity().signing_fingerprint; }
     /**
-     * gitvault-multi-writer (task 5.8) — the push pre-check: before signing an
+     * vault-multi-writer (task 5.8) — the push pre-check: before signing an
      * ORDINARY head (any operation that expects this session to already be an
      * active writer), refuse EARLY and LOCALLY when this session's own key is
      * not (or is no longer) an active writer, rather than let real
@@ -3105,13 +3105,13 @@ export class GitvaultVault {
      * `removedMidRace` (design D8/D10) distinguishes the two shapes this
      * refusal takes: `false` (the default) is the ORDINARY pre-check — this
      * session was never (or is not currently) an admitted writer, thrown as
-     * `GITVAULT_WRITER_NOT_ADMITTED`. `true` is the CAS-LOSER path
+     * `VAULT_WRITER_NOT_ADMITTED`. `true` is the CAS-LOSER path
      * specifically: a retry, after re-materializing from the winner, that
      * discovers THIS session's own key was removed by whatever won the race —
      * "stop if removed" in D8's loser-rule sequence (fetch winner → verify →
      * apply writer transition → stop if removed → rebase → rebuild → bounded
      * backoff) — thrown as the more specific, client-local
-     * `GITVAULT_WRITER_REMOVED` (D10) instead: a real prior attempt just lost
+     * `VAULT_WRITER_REMOVED` (D10) instead: a real prior attempt just lost
      * to a removal, not a caller who was never eligible.
      *
      * Deliberately NOT called for a "handoff"-door `add_writer_key` head
@@ -3123,47 +3123,47 @@ export class GitvaultVault {
         const myKey = this.writerKeyId();
         if (pin && pin.writers.some((w) => w.writer_key_id === myKey))
             return;
-        const code = removedMidRace ? "GITVAULT_WRITER_REMOVED" : "GITVAULT_WRITER_NOT_ADMITTED";
+        const code = removedMidRace ? "VAULT_WRITER_REMOVED" : "VAULT_WRITER_NOT_ADMITTED";
         fail(code, removedMidRace
             ? `this session's writer key (${myKey}) was removed while a conflicting head was admitted first`
             : `this session's writer key (${myKey}) is not an active writer on this vault`, context, {}, [
             {
                 type: "request_writer_sync",
-                why: "This session's key is not (yet, or no longer) an admitted writer on this vault. If you were just added as an org member, any current writer's next gitvault operation (push, deploy, or r.gitvault.reconcile()) admits pending writers automatically.",
+                why: "This session's key is not (yet, or no longer) an admitted writer on this vault. If you were just added as an org member, any current writer's next vault operation (push, deploy, or r.repos.reconcile()) admits pending writers automatically.",
             },
         ]);
     }
-    /** The owner's full signing keypair, or `GITVAULT_READ_ONLY` — same refusal path as {@link signer}, which returns only the seed; {@link sealKeyEnvelope} needs both halves. */
+    /** The owner's full signing keypair, or `VAULT_READ_ONLY` — same refusal path as {@link signer}, which returns only the seed; {@link sealKeyEnvelope} needs both halves. */
     signingKeypair() {
         const identity = this.keystore.ensureIdentity();
         const kp = this.keystore.signingKeypair(identity);
         if (!kp)
-            fail("GITVAULT_READ_ONLY", "the signing key is missing from identity.json; this principal is read-only", "signing gitvault object", undefined, [{ action: "stay read-only at the materialized pin" }]);
+            fail("VAULT_READ_ONLY", "the signing key is missing from identity.json; this principal is read-only", "signing vault object", undefined, [{ action: "stay read-only at the materialized pin" }]);
         return kp;
     }
     buildRefState(generation, refs, headTarget, keyOverride) {
         if (headTarget.kind === "symref" && !BRANCH_REF_RE.test(headTarget.ref))
             fail("REFNAME_UNSUPPORTED", `head_target symref must name a refs/heads/* branch: ${headTarget.ref}`, "building ref_state");
-        if (headTarget.kind === "detached" && !GITVAULT_OID40_RE.test(headTarget.oid))
+        if (headTarget.kind === "detached" && !VAULT_OID40_RE.test(headTarget.oid))
             fail("REF_TRANSACTION_INVALID", "detached head_target needs a 40-hex oid", "building ref_state");
         assertRefMapCardinality(refs);
         const sorted = {};
         for (const k of Object.keys(refs).sort())
             sorted[k] = refs[k];
-        const id = newGitvaultId("refs");
-        const object = signGitvaultObject({ format: GITVAULT_FORMAT, object_kind: "ref_state", suite: GITVAULT_SUITE, repo_id: this.repoId, object_id: id, generation, refs: sorted, head_target: headTarget }, this.signer());
+        const id = newVaultId("refs");
+        const object = signVaultObject({ format: VAULT_FORMAT, object_kind: "ref_state", suite: VAULT_SUITE, repo_id: this.repoId, object_id: id, generation, refs: sorted, head_target: headTarget }, this.signer());
         const plaintext = storedBytes(object);
-        if (plaintext.length > GITVAULT_MAX_REF_STATE_OBJECT_BYTES)
+        if (plaintext.length > VAULT_MAX_REF_STATE_OBJECT_BYTES)
             fail("REF_STATE_LIMIT_EXCEEDED", "ref_state object exceeds 32 MiB", "building ref_state");
-        return { object, upload: this.seal("ref_state", id, plaintext, gitvaultPaths.refState(id), keyOverride) };
+        return { object, upload: this.seal("ref_state", id, plaintext, vaultPaths.refState(id), keyOverride) };
     }
     buildRetentionRoots(generation, roots, cutoff, keyOverride) {
-        const id = newGitvaultId("rr");
-        const object = signGitvaultObject({ format: GITVAULT_FORMAT, object_kind: "retention_roots", suite: GITVAULT_SUITE, repo_id: this.repoId, object_id: id, generation, cutoff, roots: [...roots].sort(compareRoots) }, this.signer());
+        const id = newVaultId("rr");
+        const object = signVaultObject({ format: VAULT_FORMAT, object_kind: "retention_roots", suite: VAULT_SUITE, repo_id: this.repoId, object_id: id, generation, cutoff, roots: [...roots].sort(compareRoots) }, this.signer());
         const plaintext = storedBytes(object);
-        if (plaintext.length > GITVAULT_MAX_REF_STATE_OBJECT_BYTES)
+        if (plaintext.length > VAULT_MAX_REF_STATE_OBJECT_BYTES)
             fail("REF_STATE_LIMIT_EXCEEDED", "retention_roots object exceeds 32 MiB", "building retention_roots");
-        return { object, upload: this.seal("retention_roots", id, plaintext, gitvaultPaths.retentionRoots(id), keyOverride) };
+        return { object, upload: this.seal("retention_roots", id, plaintext, vaultPaths.retentionRoots(id), keyOverride) };
     }
     /** Plaintext, independently non-thin packs covering `reachable(tips) ∖ reachable(base)`, split at the multi-object target. */
     async buildPacks(tips, base) {
@@ -3177,7 +3177,7 @@ export class GitvaultVault {
         // genuine local gap and is named as such.
         const uniqueTips = [];
         for (const t of new Set(tips)) {
-            if (!GITVAULT_OID40_RE.test(t))
+            if (!VAULT_OID40_RE.test(t))
                 continue;
             if (await hasObject(dir, t)) {
                 uniqueTips.push(t);
@@ -3185,13 +3185,13 @@ export class GitvaultVault {
             }
             if (baseSet.has(t))
                 continue;
-            fail("GIT_COMMAND_FAILED", `tip ${t} is not in this checkout's object store and the vault does not cover it yet — fetch it before publishing`, "building gitvault packs", { oid: t });
+            fail("GIT_COMMAND_FAILED", `tip ${t} is not in this checkout's object store and the vault does not cover it yet — fetch it before publishing`, "building vault packs", { oid: t });
         }
         if (uniqueTips.length === 0)
             return [];
         const presentBase = [];
         for (const b of baseSet)
-            if (GITVAULT_OID40_RE.test(b) && (await hasObject(dir, b)))
+            if (VAULT_OID40_RE.test(b) && (await hasObject(dir, b)))
                 presentBase.push(b);
         // On the object store's own filesystem — `git pack-objects` rename(2)s
         // its temp pack from `objects/pack/` onto this base (see
@@ -3199,7 +3199,7 @@ export class GitvaultVault {
         const tmp = await allocatePackScratchDir(dir);
         try {
             const revs = [...uniqueTips, ...presentBase.map((b) => `^${b}`)].join("\n") + "\n";
-            await hardenedGit(dir, ["pack-objects", "--revs", "--no-reuse-delta", "--delta-base-offset", `--max-pack-size=${GITVAULT_MULTI_OBJECT_PACK_TARGET_BYTES}`, "-q", join(tmp, "p")], { input: revs });
+            await hardenedGit(dir, ["pack-objects", "--revs", "--no-reuse-delta", "--delta-base-offset", `--max-pack-size=${VAULT_MULTI_OBJECT_PACK_TARGET_BYTES}`, "-q", join(tmp, "p")], { input: revs });
             const files = readdirSync(tmp).filter((f) => f.endsWith(".pack")).sort();
             return files.map((f) => new Uint8Array(readFileSync(join(tmp, f))));
         }
@@ -3220,7 +3220,7 @@ export class GitvaultVault {
      * parameterized by directory, rather than a second rev-list at the call site.
      */
     async objectSetIn(dir, tips) {
-        const unique = [...new Set(tips)].filter((t) => GITVAULT_OID40_RE.test(t));
+        const unique = [...new Set(tips)].filter((t) => VAULT_OID40_RE.test(t));
         if (unique.length === 0)
             return [];
         const out = await hardenedGit(dir, ["rev-list", "--objects", "--no-object-names", ...unique]);
@@ -3236,7 +3236,7 @@ export class GitvaultVault {
      */
     async openRetentionRootsAt(receipt) {
         const { genesis } = await this.genesis();
-        return this.openCarrier("retention_roots", receipt, gitvaultPaths.retentionRoots(receipt.object_id), genesis.creator_signing_pubkey);
+        return this.openCarrier("retention_roots", receipt, vaultPaths.retentionRoots(receipt.object_id), genesis.creator_signing_pubkey);
     }
     digest(label, content) {
         return keyedCommitment(deriveDigestKey(this.kRepo(), this.repoId, this.epoch(), label), content);
@@ -3278,7 +3278,7 @@ export class GitvaultVault {
      * recomputed). Coverage above the V0 maximum → `CHECKPOINT_SET_LIMIT_EXCEEDED`.
      */
     async buildCheckpoint(input) {
-        const tips = GitvaultVault.coverageTips(input.ref_state.refs, input.retention_roots.roots, input.ref_state.head_target);
+        const tips = Vault.coverageTips(input.ref_state.refs, input.retention_roots.roots, input.ref_state.head_target);
         const absent = [];
         for (const t of tips)
             if (!(await hasObject(this.git(), t)))
@@ -3298,15 +3298,15 @@ export class GitvaultVault {
                     fail("CHECKPOINT_INCOMPLETE", `covered tip ${t} is not present locally and the vault did not supply it; the checkpoint cannot be built from this repository`, "building checkpoint set", { oid: t });
         }
         const packs = await this.buildPacks(tips, []);
-        if (packs.length > GITVAULT_MAX_CHECKPOINT_PACKS)
-            fail("CHECKPOINT_SET_LIMIT_EXCEEDED", `${packs.length} packs exceed the ${GITVAULT_MAX_CHECKPOINT_PACKS}-pack V0 checkpoint maximum`, "building checkpoint set", undefined, [{ action: "compact or prune before adding coverage" }]);
+        if (packs.length > VAULT_MAX_CHECKPOINT_PACKS)
+            fail("CHECKPOINT_SET_LIMIT_EXCEEDED", `${packs.length} packs exceed the ${VAULT_MAX_CHECKPOINT_PACKS}-pack V0 checkpoint maximum`, "building checkpoint set", undefined, [{ action: "compact or prune before adding coverage" }]);
         const entries = [];
         const objects = [];
         let totalPlain = 0n;
         let totalStored = 0n;
         for (const pack of packs) {
-            const id = newGitvaultId("ckp");
-            const upload = this.seal("checkpoint_pack", id, pack, gitvaultPaths.checkpointPack(id));
+            const id = newVaultId("ckp");
+            const upload = this.seal("checkpoint_pack", id, pack, vaultPaths.checkpointPack(id));
             objects.push(upload);
             entries.push({ object_id: id, plaintext_sha256: sha256Hex(pack), plaintext_size_bytes: String(pack.length), ciphertext_sha256: upload.sha256, size_bytes: upload.size_bytes });
             totalPlain += BigInt(pack.length);
@@ -3314,26 +3314,26 @@ export class GitvaultVault {
         }
         const objectIds = await this.objectSet(tips);
         const manifestUnsigned = {
-            format: GITVAULT_FORMAT, object_kind: "checkpoint_manifest", suite: GITVAULT_SUITE, repo_id: this.repoId, object_id: newGitvaultId("chk"),
+            format: VAULT_FORMAT, object_kind: "checkpoint_manifest", suite: VAULT_SUITE, repo_id: this.repoId, object_id: newVaultId("chk"),
             covers_through_generation: input.generation, git_object_format: "sha1", packs: entries, total_plaintext_size_bytes: String(totalPlain),
             ref_state_hmac: this.digest("refmap", this.withoutSignature(input.ref_state)),
             retention_roots_hmac: this.digest("rootset", this.withoutSignature(input.retention_roots)),
             object_set_hmac: this.digest("objectset", { oids: objectIds }),
         };
-        const manifest = signGitvaultObject(manifestUnsigned, this.signer());
-        const manifestUpload = this.seal("checkpoint_manifest", manifest.object_id, storedBytes(manifest), gitvaultPaths.checkpointManifest(manifest.object_id));
+        const manifest = signVaultObject(manifestUnsigned, this.signer());
+        const manifestUpload = this.seal("checkpoint_manifest", manifest.object_id, storedBytes(manifest), vaultPaths.checkpointManifest(manifest.object_id));
         objects.unshift(manifestUpload);
         totalStored += BigInt(manifestUpload.size_bytes);
-        if (totalStored > GITVAULT_MAX_CHECKPOINT_TOTAL_STORED_BYTES)
+        if (totalStored > VAULT_MAX_CHECKPOINT_TOTAL_STORED_BYTES)
             fail("CHECKPOINT_SET_LIMIT_EXCEEDED", "the checkpoint's stored bytes exceed the 800 GiB V0 maximum", "building checkpoint set", { total_stored_size_bytes: String(totalStored) }, [{ action: "compact or prune before adding coverage" }]);
-        const claimSet = signGitvaultObject({
-            format: GITVAULT_FORMAT, object_kind: "checkpoint_claim_set", suite: GITVAULT_SUITE, repo_id: this.repoId, object_id: newGitvaultId("ccs"),
+        const claimSet = signVaultObject({
+            format: VAULT_FORMAT, object_kind: "checkpoint_claim_set", suite: VAULT_SUITE, repo_id: this.repoId, object_id: newVaultId("ccs"),
             manifest_receipt: { object_id: manifest.object_id, object_kind: "checkpoint_manifest", ciphertext_sha256: manifestUpload.sha256, size_bytes: manifestUpload.size_bytes },
             ordered_pack_receipts: entries.map((e) => ({ object_id: e.object_id, object_kind: "checkpoint_pack", ciphertext_sha256: e.ciphertext_sha256, size_bytes: e.size_bytes })),
             total_stored_size_bytes: String(totalStored), covers_through_generation: input.generation, writer_key_id: this.writerKeyId(),
         }, this.signer());
         const claimBytes = storedBytes(claimSet);
-        const claimUpload = { path: gitvaultPaths.claimSet(claimSet.object_id), object_kind: "checkpoint_claim_set", object_id: claimSet.object_id, bytes: claimBytes, sha256: sha256Hex(claimBytes), size_bytes: String(claimBytes.length) };
+        const claimUpload = { path: vaultPaths.claimSet(claimSet.object_id), object_kind: "checkpoint_claim_set", object_id: claimSet.object_id, bytes: claimBytes, sha256: sha256Hex(claimBytes), size_bytes: String(claimBytes.length) };
         objects.push(claimUpload);
         const built = { manifest, claim_set: claimSet, claim_set_receipt: { object_id: claimSet.object_id, object_kind: "checkpoint_claim_set", stored_bytes_sha256: claimUpload.sha256, size_bytes: claimUpload.size_bytes }, objects, packs, covered_tips: tips };
         await this.acceptCheckpoint(built, input.ref_state, input.retention_roots);
@@ -3342,13 +3342,13 @@ export class GitvaultVault {
     /** §4.7 acceptance: restore from the set ALONE into an empty scratch; every covered ref resolves; fsck connectivity; recompute the three commitments. */
     async acceptCheckpoint(built, refState, roots) {
         checkClaimSetEquality(built.claim_set, built.manifest, built.claim_set.covers_through_generation);
-        const scratch = mkdtempSync(join(tmpdir(), "run402-gitvault-accept-"));
+        const scratch = mkdtempSync(join(tmpdir(), "run402-vault-accept-"));
         try {
             await hardenedGit(scratch, ["init", "-q", "--bare", "--object-format=sha1", "."]);
             for (const pack of built.packs) {
                 await hardenedGit(scratch, ["index-pack", "--stdin", "--strict"], { input: pack });
             }
-            const tips = GitvaultVault.coverageTips(refState.refs, roots.roots, refState.head_target);
+            const tips = Vault.coverageTips(refState.refs, roots.roots, refState.head_target);
             for (const t of tips) {
                 if (!(await hasObject(scratch, t)))
                     fail("CHECKPOINT_INCOMPLETE", `covered tip ${t} does not resolve from the restored set`, "accepting checkpoint set", { oid: t }, [{ action: "rebuild the checkpoint set; restorers fall back to WAL replay" }]);
@@ -3384,7 +3384,7 @@ export class GitvaultVault {
         if (!block)
             fail("CHECKPOINT_INCOMPLETE", `head ${head.generation} carries no checkpoint to verify`, "verifying a stored checkpoint", { generation: head.generation });
         const { genesis } = await this.genesis();
-        // gitvault-multi-writer rev 47: `head` may have been signed by any
+        // vault-multi-writer rev 47: `head` may have been signed by any
         // CURRENTLY-KNOWN writer, not just the genesis creator — resolved from
         // the keystore's persisted `writer_set_pin` (the same substrate
         // `verifyToNewest` maintains), falling back to the genesis-creator key
@@ -3394,23 +3394,23 @@ export class GitvaultVault {
         // same documented residual as the backward-catch-up decrypt path above —
         // `writer_set_pin` only remembers currently-active writers, not burned ones.
         const writerKey = this.writerKeyForHead(head, genesis.creator_signing_pubkey);
-        const claimBytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.claimSet(block.claim_set.object_id), expected_sha256: block.claim_set.stored_bytes_sha256 });
+        const claimBytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.claimSet(block.claim_set.object_id), expected_sha256: block.claim_set.stored_bytes_sha256 });
         if (!claimBytes || sha256Hex(claimBytes) !== block.claim_set.stored_bytes_sha256) {
             fail("CHECKPOINT_INCOMPLETE", `checkpoint claim set ${block.claim_set.object_id} is absent or does not match the head's receipt`, "verifying a stored checkpoint", { object_id: block.claim_set.object_id });
         }
-        const claimSet = parseGitvaultStrict(new TextDecoder().decode(claimBytes));
-        if (!verifyGitvaultObject(claimSet, writerKey))
+        const claimSet = parseVaultStrict(new TextDecoder().decode(claimBytes));
+        if (!verifyVaultObject(claimSet, writerKey))
             fail("CHECKPOINT_INCOMPLETE", "checkpoint claim set signature fails", "verifying a stored checkpoint", { object_id: claimSet.object_id });
-        const manifest = await this.openCarrier("checkpoint_manifest", claimSet.manifest_receipt, gitvaultPaths.checkpointManifest(claimSet.manifest_receipt.object_id), writerKey);
+        const manifest = await this.openCarrier("checkpoint_manifest", claimSet.manifest_receipt, vaultPaths.checkpointManifest(claimSet.manifest_receipt.object_id), writerKey);
         checkClaimSetEquality(claimSet, manifest, block.covers_through_generation);
-        const refState = await this.openCarrier("ref_state", head.ref_state, gitvaultPaths.refState(head.ref_state.object_id), writerKey);
-        const roots = await this.openCarrier("retention_roots", head.retention_roots, gitvaultPaths.retentionRoots(head.retention_roots.object_id), writerKey);
-        const tips = GitvaultVault.coverageTips(refState.refs, roots.roots, refState.head_target);
-        const scratch = mkdtempSync(join(tmpdir(), "run402-gitvault-attest-"));
+        const refState = await this.openCarrier("ref_state", head.ref_state, vaultPaths.refState(head.ref_state.object_id), writerKey);
+        const roots = await this.openCarrier("retention_roots", head.retention_roots, vaultPaths.retentionRoots(head.retention_roots.object_id), writerKey);
+        const tips = Vault.coverageTips(refState.refs, roots.roots, refState.head_target);
+        const scratch = mkdtempSync(join(tmpdir(), "run402-vault-attest-"));
         try {
             await hardenedGit(scratch, ["init", "-q", "--bare", "--object-format=sha1", "."]);
             for (const p of manifest.packs) {
-                const frame = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.checkpointPack(p.object_id), expected_sha256: p.ciphertext_sha256 });
+                const frame = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.checkpointPack(p.object_id), expected_sha256: p.ciphertext_sha256 });
                 if (!frame)
                     fail("CHECKPOINT_INCOMPLETE", `checkpoint pack ${p.object_id} is absent from storage`, "verifying a stored checkpoint", { object_id: p.object_id });
                 const plain = openFrame({ k_obj: deriveObjectKey(this.kRepo(), this.repoId, this.epoch(), "checkpoint_pack", p.object_id), repo_id: this.repoId, object_kind: "checkpoint_pack", object_id: p.object_id, epoch: this.epoch(), frame, expected_ciphertext_sha256: p.ciphertext_sha256 });
@@ -3466,7 +3466,7 @@ export class GitvaultVault {
         const generations = [...chain.keys()].sort();
         const out = [];
         const { genesis } = await this.genesis();
-        // gitvault-multi-writer rev 47: `verifyToNewest()` above already
+        // vault-multi-writer rev 47: `verifyToNewest()` above already
         // persisted the current `writer_set_pin` (active AND retired writers) —
         // same per-head resolution as `verifyStoredCheckpoint`.
         for (const gen of generations) {
@@ -3478,13 +3478,13 @@ export class GitvaultVault {
                 // Plaintext-structured and stored-bytes-receipted: no decryption, but
                 // the hash and the owner signature are still checked before a single
                 // pack receipt inside it is believed.
-                const bytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.claimSet(block.claim_set.object_id), expected_sha256: block.claim_set.stored_bytes_sha256 });
+                const bytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.claimSet(block.claim_set.object_id), expected_sha256: block.claim_set.stored_bytes_sha256 });
                 if (!bytes || sha256Hex(bytes) !== block.claim_set.stored_bytes_sha256) {
-                    fail("CHECKPOINT_INCOMPLETE", `checkpoint claim set ${block.claim_set.object_id} (generation ${gen}) is absent or altered`, "walking the gitvault chain", { generation: gen, object_id: block.claim_set.object_id });
+                    fail("CHECKPOINT_INCOMPLETE", `checkpoint claim set ${block.claim_set.object_id} (generation ${gen}) is absent or altered`, "walking the vault chain", { generation: gen, object_id: block.claim_set.object_id });
                 }
-                claimSet = parseGitvaultStrict(new TextDecoder().decode(bytes));
-                if (!verifyGitvaultObject(claimSet, writerKey)) {
-                    fail("CHECKPOINT_INCOMPLETE", `checkpoint claim set ${claimSet.object_id} signature fails`, "walking the gitvault chain", { generation: gen });
+                claimSet = parseVaultStrict(new TextDecoder().decode(bytes));
+                if (!verifyVaultObject(claimSet, writerKey)) {
+                    fail("CHECKPOINT_INCOMPLETE", `checkpoint claim set ${claimSet.object_id} signature fails`, "walking the vault chain", { generation: gen });
                 }
             }
             out.push({ head: entry.head, head_sha256: entry.sha256, claim_set: claimSet });
@@ -3493,19 +3493,19 @@ export class GitvaultVault {
     }
     // ── upload with receipt-compare ──
     /**
-     * gitvault-byo-primary-bucket task 3.2 — resolve (once, cached) this
+     * vault-byo-primary-bucket task 3.2 — resolve (once, cached) this
      * machine's local BYO write config for THIS vault. `null` when none is
      * configured locally — either because this is an ordinary managed vault
      * (the common case; deliberately never confirmed with a network call, so
      * a managed vault's push pays zero extra round trips), or because this
      * machine has not been configured to write a BYO vault it nonetheless
-     * belongs to (surfaced downstream as `GITVAULT_BYO_BUCKET_WRITE_REFUSED`
+     * belongs to (surfaced downstream as `VAULT_BYO_BUCKET_WRITE_REFUSED`
      * when the session actually names a `put: null` object with no target).
      */
     async resolveByoWriteTarget() {
         if (this.byoResolution !== undefined)
             return this.byoResolution;
-        const { readByoConfig } = await import("./gitvault-byo-config.js");
+        const { readByoConfig } = await import("./vault-byo-config.js");
         const local = readByoConfig(this.keystore, this.repoId);
         this.byoResolution = local ? { destination: local.destination, ...(local.credential ? { credential: local.credential } : {}) } : null;
         return this.byoResolution;
@@ -3514,10 +3514,10 @@ export class GitvaultVault {
         const byo = await this.resolveByoWriteTarget();
         const receipts = await this.transport.uploadObjects({ repo_id: this.repoId, objects, ...(byo ? { byo } : {}) });
         if (receipts.length !== objects.length)
-            fail("GITVAULT_RECEIPT_MISMATCH", `${receipts.length} receipts for ${objects.length} objects`, "comparing finalization receipts");
+            fail("VAULT_RECEIPT_MISMATCH", `${receipts.length} receipts for ${objects.length} objects`, "comparing finalization receipts");
         const mismatches = objects.filter((o, i) => receipts[i].path !== o.path || receipts[i].sha256 !== o.sha256 || receipts[i].size_bytes !== o.size_bytes);
         if (mismatches.length > 0) {
-            fail("GITVAULT_RECEIPT_MISMATCH", `the server's finalization receipts do not match the expected manifest for ${mismatches.map((m) => m.path).join(", ")}; refusing to sign a head over them`, "comparing finalization receipts", { paths: mismatches.map((m) => m.path) });
+            fail("VAULT_RECEIPT_MISMATCH", `the server's finalization receipts do not match the expected manifest for ${mismatches.map((m) => m.path).join(", ")}; refusing to sign a head over them`, "comparing finalization receipts", { paths: mismatches.map((m) => m.path) });
         }
     }
     // ── §6.2 push ──
@@ -3540,8 +3540,8 @@ export class GitvaultVault {
         });
         const refState = this.buildRefState(generation, input.refs, input.head_target);
         const rootsObj = this.buildRetentionRoots(generation, roots, ticket ? { cutoff_ticket_sha256: ticket.receipt.stored_bytes_sha256, cutoff_at: ticket.ticket.cutoff_at } : null);
-        const baseTips = GitvaultVault.coverageTips(base.refs, base.roots, base.head_target);
-        const newTips = GitvaultVault.coverageTips(input.refs, roots, input.head_target);
+        const baseTips = Vault.coverageTips(base.refs, base.roots, base.head_target);
+        const newTips = Vault.coverageTips(input.refs, roots, input.head_target);
         // Preflight the projected coverage against the V0 checkpoint maximum (client-side, plaintext projection).
         const walPacks = input.force_checkpoint ? [] : await this.buildPacks(newTips, baseTips);
         let form;
@@ -3549,7 +3549,7 @@ export class GitvaultVault {
         let checkpoint = null;
         const objects = [refState.upload, rootsObj.upload];
         let rawPackBytes = 0;
-        if (input.force_checkpoint || walPacks.length > GITVAULT_MAX_WAL_RECEIPTS_PER_HEAD) {
+        if (input.force_checkpoint || walPacks.length > VAULT_MAX_WAL_RECEIPTS_PER_HEAD) {
             form = "checkpoint";
             const built = await this.buildCheckpoint({ generation, ref_state: refState.object, retention_roots: rootsObj.object });
             objects.push(...built.objects);
@@ -3559,8 +3559,8 @@ export class GitvaultVault {
         else {
             form = "wal";
             for (const pack of walPacks) {
-                const id = newGitvaultId("wal");
-                const upload = { ...this.seal("wal_pack", id, pack, gitvaultPaths.wal(id)), base_generation: base.generation };
+                const id = newVaultId("wal");
+                const upload = { ...this.seal("wal_pack", id, pack, vaultPaths.wal(id)), base_generation: base.generation };
                 objects.push(upload);
                 walEntries.push({ object_id: id, object_kind: "wal_pack", ciphertext_sha256: upload.sha256, size_bytes: upload.size_bytes, base_generation: base.generation });
                 rawPackBytes += pack.length;
@@ -3581,7 +3581,7 @@ export class GitvaultVault {
             retention_roots: { object_id: rootsObj.object.object_id, object_kind: "retention_roots", ciphertext_sha256: rootsObj.upload.sha256, size_bytes: rootsObj.upload.size_bytes },
             checkpoint, checkpoint_purpose: checkpoint ? "ordinary_push" : null, capture_binding: binding, repair: null,
         }, 
-        // gitvault-multi-writer (task 5.6) — an `add_writer_key` activation
+        // vault-multi-writer (task 5.6) — an `add_writer_key` activation
         // head rides THIS same content-neutral machinery: `input.transition`
         // is undefined for every pre-existing caller (push/publishCheckpoint),
         // so their heads are byte-for-byte unchanged; `submitWriterActivationHead`
@@ -3605,14 +3605,14 @@ export class GitvaultVault {
         let removalRotated = false;
         let base = options.base ?? (await this.materialize());
         for (;;) {
-            // gitvault-multi-writer (task 5.8) — checked fresh on EVERY attempt
+            // vault-multi-writer (task 5.8) — checked fresh on EVERY attempt
             // (including a CAS-loser retry, design D8's "stop if removed"): a
             // concurrent rotation could remove this session's own writer key
             // between one attempt and the next. `conflicts > 0` is exactly the
             // CAS-loser path (this iteration only runs after losing a race and
-            // re-materializing from the winner) — GITVAULT_WRITER_REMOVED there,
-            // the ordinary GITVAULT_WRITER_NOT_ADMITTED on the first attempt.
-            this.assertCallerIsWriter("publishing gitvault head", conflicts > 0);
+            // re-materializing from the winner) — VAULT_WRITER_REMOVED there,
+            // the ordinary VAULT_WRITER_NOT_ADMITTED on the first attempt.
+            this.assertCallerIsWriter("publishing vault head", conflicts > 0);
             const evaluation = await evaluateRefTransaction(base.refs, options.transaction, { isAncestor: (a, d) => isAncestor(this.git(), a, d), protocol_refs: options.protocol_refs });
             let published;
             try {
@@ -3622,8 +3622,8 @@ export class GitvaultVault {
                 });
             }
             catch (e) {
-                // gitvault-human-envelopes D5 ("Remove: next capture rotates the
-                // epoch key to the remaining set") / gitvault-multi-writer D6: an
+                // vault-human-envelopes D5 ("Remove: next capture rotates the
+                // epoch key to the remaining set") / vault-multi-writer D6: an
                 // outstanding MEMBERSHIP REMOVAL is completed by the next push of any
                 // surviving writer — rotate under the writer-capable
                 // reason:"member_removed", re-materialize on the rotated chain, and
@@ -3645,15 +3645,15 @@ export class GitvaultVault {
             if (published.outcome === "conflict") {
                 conflicts += 1;
                 if (conflicts > this.retries)
-                    fail("HEAD_CAS_CONFLICT", `admission lost ${conflicts} races at generation ${published.generation}; giving up`, "publishing gitvault head", { generation: published.generation, winner: published.winner }, [{ action: "verify the attached winner from storage, rebase, retry" }]);
+                    fail("HEAD_CAS_CONFLICT", `admission lost ${conflicts} races at generation ${published.generation}; giving up`, "publishing vault head", { generation: published.generation, winner: published.winner }, [{ action: "verify the attached winner from storage, rebase, retry" }]);
                 base = await this.materialize(); // re-verify from storage (the winner) before re-applying the transaction
                 continue;
             }
             // `push()` never sets `dry_run`, so this outcome is unreachable here —
             // narrows `published` to `"admitted"` for the return below.
             if (published.outcome === "dry_run")
-                fail("GIT_COMMAND_FAILED", "internal: push() received a dry-run result it never requested", "publishing gitvault head");
-            this.keystore.updateRepo(this.repoId, { last_ref_transaction: { generation: published.generation, transaction: options.transaction, at: formatGitvaultTimestamp(this.now()) } });
+                fail("GIT_COMMAND_FAILED", "internal: push() received a dry-run result it never requested", "publishing vault head");
+            this.keystore.updateRepo(this.repoId, { last_ref_transaction: { generation: published.generation, transaction: options.transaction, at: formatVaultTimestamp(this.now()) } });
             return { generation: published.generation, head_sha256: published.head_sha256, head: published.head, admission_record_sha256: published.admission_record_sha256, capture_receipt: published.capture_receipt, form: published.form, conflicts_retried: conflicts, refs: published.refs, checkpoint_staleness: this.checkpointStalenessNow(published.generation) };
         }
     }
@@ -3672,8 +3672,8 @@ export class GitvaultVault {
      *
      * Never retries and never allocates: an unallocated vault has no `repo_id`
      * (hence no encryption key) to preview a push against at all — callers
-     * resolve the vault READ-ONLY first (see `Gitvault.planPush` in
-     * `../namespaces/gitvault.js`, which reports `allocation_needed: true` in
+     * resolve the vault READ-ONLY first (see `Repos.planCapture` in
+     * `../namespaces/repos.js`, which reports `allocation_needed: true` in
      * that case instead of calling this method).
      */
     async planPush(options) {
@@ -3692,7 +3692,7 @@ export class GitvaultVault {
         // `"dry_run"` outcome — `"conflict"`/`"admitted"` are reachable only via
         // `admit()`, which a dry run never calls.
         if (published.outcome !== "dry_run")
-            fail("GIT_COMMAND_FAILED", "internal: planPush did not receive a dry-run result", "planning gitvault push");
+            fail("GIT_COMMAND_FAILED", "internal: planPush did not receive a dry-run result", "planning vault push");
         const encryptedBytes = published.objects.reduce((sum, o) => sum + BigInt(o.size_bytes), 0n);
         return {
             base_generation: base.generation,
@@ -3721,7 +3721,7 @@ export class GitvaultVault {
      * `prepared_at` alone would shorten the lane, which the protocol's own
      * delayed-PUT vector calls out as the naive implementation.
      *
-     * This is NOT `run402 gitvault compact`: the §7.2 maintenance CYCLE (purpose
+     * This is NOT `run402 repos gc`: the §7.2 maintenance CYCLE (purpose
      * `maintenance_cycle`, C1/C2 roles, stage claim sets, prune intents, `R2_cap`
      * accounting) is a separate protocol under compact authority, and gets its own
      * method when it ships.
@@ -3737,13 +3737,13 @@ export class GitvaultVault {
             if (published.outcome === "conflict") {
                 conflicts += 1;
                 if (conflicts > this.retries)
-                    fail("HEAD_CAS_CONFLICT", `the checkpoint lost ${conflicts} races at generation ${published.generation}; giving up`, "publishing gitvault checkpoint", { generation: published.generation, winner: published.winner }, [{ action: "verify the attached winner from storage, retry" }]);
+                    fail("HEAD_CAS_CONFLICT", `the checkpoint lost ${conflicts} races at generation ${published.generation}; giving up`, "publishing vault checkpoint", { generation: published.generation, winner: published.winner }, [{ action: "verify the attached winner from storage, retry" }]);
                 continue;
             }
             // `publishCheckpoint` never sets `dry_run`, so this outcome is
             // unreachable here — narrows `published` to `"admitted"` below.
             if (published.outcome === "dry_run")
-                fail("GIT_COMMAND_FAILED", "internal: publishCheckpoint() received a dry-run result it never requested", "publishing gitvault checkpoint");
+                fail("GIT_COMMAND_FAILED", "internal: publishCheckpoint() received a dry-run result it never requested", "publishing vault checkpoint");
             return { generation: published.generation, head_sha256: published.head_sha256, head: published.head, admission_record_sha256: published.admission_record_sha256, capture_receipt: published.capture_receipt, form: published.form, conflicts_retried: conflicts, refs: published.refs, checkpoint_staleness: this.checkpointStalenessNow(published.generation) };
         }
     }
@@ -3752,12 +3752,12 @@ export class GitvaultVault {
         const issued = await this.transport.requestRetentionCutoff({ repo_id: this.repoId, base_head_sha256: baseHeadSha256 });
         const t = issued.ticket;
         if (t.object_kind !== "retention_cutoff" || t.repo_id !== this.repoId || t.base_head_sha256 !== baseHeadSha256) {
-            fail("GITVAULT_CUTOFF_TICKET_INVALID", `the retention cutoff ticket does not bind this vault's base head ${baseHeadSha256}`, "requesting retention cutoff ticket", { object_id: t.object_id, base_head_sha256: t.base_head_sha256 });
+            fail("VAULT_CUTOFF_TICKET_INVALID", `the retention cutoff ticket does not bind this vault's base head ${baseHeadSha256}`, "requesting retention cutoff ticket", { object_id: t.object_id, base_head_sha256: t.base_head_sha256 });
         }
         if (Date.parse(t.expires_at) <= this.now().getTime())
-            fail("GITVAULT_CUTOFF_TICKET_INVALID", `the retention cutoff ticket expired at ${t.expires_at}`, "requesting retention cutoff ticket", { object_id: t.object_id });
-        if (this.servicePublicKey && !verifyGitvaultObject(t, this.servicePublicKey)) {
-            fail("GITVAULT_CUTOFF_TICKET_INVALID", "the retention cutoff ticket is not signed by the pinned service key", "requesting retention cutoff ticket", { object_id: t.object_id, service_key_id: t.service_key_id });
+            fail("VAULT_CUTOFF_TICKET_INVALID", `the retention cutoff ticket expired at ${t.expires_at}`, "requesting retention cutoff ticket", { object_id: t.object_id });
+        if (this.servicePublicKey && !verifyVaultObject(t, this.servicePublicKey)) {
+            fail("VAULT_CUTOFF_TICKET_INVALID", "the retention cutoff ticket is not signed by the pinned service key", "requesting retention cutoff ticket", { object_id: t.object_id, service_key_id: t.service_key_id });
         }
         return issued;
     }
@@ -3777,15 +3777,15 @@ export class GitvaultVault {
      */
     signHead(fields, overrides) {
         const unsigned = {
-            format: GITVAULT_FORMAT, object_kind: "head", suite: GITVAULT_SUITE, repo_id: this.repoId,
+            format: VAULT_FORMAT, object_kind: "head", suite: VAULT_SUITE, repo_id: this.repoId,
             generation: fields.generation, prev_sha256: fields.prev_sha256, epoch: overrides?.epoch ?? this.epoch(),
             wal_entries: fields.wal_entries, ref_state: fields.ref_state, retention_roots: fields.retention_roots,
             checkpoint: fields.checkpoint, checkpoint_purpose: fields.checkpoint_purpose, capture_binding: fields.capture_binding,
             repair: fields.repair, transition: overrides?.transition ?? null,
             ...(overrides?.pin_manifest ? { pin_manifest: overrides.pin_manifest } : {}),
-            writer_key_id: this.writerKeyId(), created_at: formatGitvaultTimestamp(this.now()),
+            writer_key_id: this.writerKeyId(), created_at: formatVaultTimestamp(this.now()),
         };
-        return signGitvaultObject(unsigned, this.signer());
+        return signVaultObject(unsigned, this.signer());
     }
     /** Admit a signed head; on success read it back from storage and compare BEFORE any pin advances. */
     async admit(head) {
@@ -3797,27 +3797,27 @@ export class GitvaultVault {
         // Post-admit readback is a spec-mandated verification obligation, never
         // a cache lookup — it exists to prove the SERVER stored what was sent,
         // which only a genuine network read can answer.
-        const back = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.head(head.generation) });
+        const back = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.head(head.generation) });
         if (!back || sha256Hex(back) !== hash) {
-            fail("GITVAULT_HEAD_READBACK_MISMATCH", `the admitted head at generation ${head.generation} read back ${back ? sha256Hex(back) : "absent"} ≠ ${hash}; the push is NOT reported as landed and no pin advances`, "reading back admitted head", { generation: head.generation, expected: hash, observed: back ? sha256Hex(back) : null });
+            fail("VAULT_HEAD_READBACK_MISMATCH", `the admitted head at generation ${head.generation} read back ${back ? sha256Hex(back) : "absent"} ≠ ${hash}; the push is NOT reported as landed and no pin advances`, "reading back admitted head", { generation: head.generation, expected: hash, observed: back ? sha256Hex(back) : null });
         }
         // Design D3: the readback just network-confirmed these exact bytes —
         // warm the cache with them so the NEXT operation (this session's own
         // `materialize` retry, or a later invocation) can skip re-fetching this
         // generation's head entirely.
         this.keystore.writeCachedHead(this.repoId, head.generation, hash, back);
-        const pin = { generation: head.generation, head_sha256: hash, pinned_at: formatGitvaultTimestamp(this.now()) };
+        const pin = { generation: head.generation, head_sha256: hash, pinned_at: formatVaultTimestamp(this.now()) };
         this.keystore.updateRepo(this.repoId, {
             head_pin: pin,
             materialized_pin: pin,
             verified_prefix: null,
-            // gitvault-clone-scaling (P3): a checkpoint-form head IS fresh
+            // vault-clone-scaling (P3): a checkpoint-form head IS fresh
             // coverage this checkout just learned first-hand.
             ...(head.checkpoint ? { checkpoint_covers_through: head.checkpoint.covers_through_generation } : {}),
         });
         return { outcome: "admitted", head_sha256: hash, admission_record_sha256: result.admission_record_sha256, capture_receipt: result.capture_receipt };
     }
-    // ── epoch rotation (D193-D203, rev 42, change gitvault-human-envelopes) ──
+    // ── epoch rotation (D193-D203, rev 42, change vault-human-envelopes) ──
     /**
      * Walk the chain BACKWARD from the current tip to find the nearest
      * admitted `recipient_pin_manifest` receipt (D197: "a fresh client... reads
@@ -3840,20 +3840,20 @@ export class GitvaultVault {
         let gen = generationToBigInt(newestGeneration);
         while (gen >= 1n) {
             const generation = gen.toString(16).padStart(16, "0");
-            const bytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.head(generation) });
+            const bytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.head(generation) });
             if (!bytes)
                 fail("CHAIN_BROKEN", `head ${generation} is missing from storage while resolving the effective pin manifest`, "resolving the effective recipient pin manifest", { generation });
-            const head = parseGitvaultStrict(new TextDecoder().decode(bytes));
+            const head = parseVaultStrict(new TextDecoder().decode(bytes));
             if (head.pin_manifest)
                 return this.readPinManifestObject(head.pin_manifest);
             gen -= 1n;
         }
         if (genesis.pin_manifest)
             return this.readPinManifestObject(genesis.pin_manifest);
-        return { pinManifestVersion: "0".repeat(16), pinManifestSha256: GITVAULT_ZERO_SHA256_SENTINEL, pinnedFingerprintOf: new Map() };
+        return { pinManifestVersion: "0".repeat(16), pinManifestSha256: VAULT_ZERO_SHA256_SENTINEL, pinnedFingerprintOf: new Map() };
     }
     /**
-     * Local-cache short-circuit (see {@link GitvaultRepoFile.known_pin_manifest}'s
+     * Local-cache short-circuit (see {@link VaultRepoFile.known_pin_manifest}'s
      * own doc comment for why this is safe): a manifest THIS keystore itself
      * just built, signed, and admitted is resolved from the on-disk cache
      * instead of a network `object-reads` round trip — same return shape,
@@ -3877,18 +3877,18 @@ export class GitvaultVault {
         if (known && known.pin_manifest_version === receipt.pin_manifest_version && known.stored_bytes_sha256 === receipt.stored_bytes_sha256) {
             return { pinManifestVersion: known.pin_manifest_version, pinManifestSha256: known.stored_bytes_sha256, pinnedFingerprintOf: new Map(known.pins.map((p) => [p.principal_id, p.ek_fingerprint])) };
         }
-        const bytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.pinManifest(receipt.pin_manifest_version), expected_sha256: receipt.stored_bytes_sha256 });
+        const bytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.pinManifest(receipt.pin_manifest_version), expected_sha256: receipt.stored_bytes_sha256 });
         if (!bytes || sha256Hex(bytes) !== receipt.stored_bytes_sha256) {
-            fail("GITVAULT_RECEIPT_MISMATCH", `recipient_pin_manifest ${receipt.pin_manifest_version} is absent or does not match its receipted hash`, "resolving the effective recipient pin manifest", { pin_manifest_version: receipt.pin_manifest_version });
+            fail("VAULT_RECEIPT_MISMATCH", `recipient_pin_manifest ${receipt.pin_manifest_version} is absent or does not match its receipted hash`, "resolving the effective recipient pin manifest", { pin_manifest_version: receipt.pin_manifest_version });
         }
-        const manifest = parseGitvaultStrict(new TextDecoder().decode(bytes));
+        const manifest = parseVaultStrict(new TextDecoder().decode(bytes));
         const { genesis } = await this.genesis();
-        // gitvault-multi-writer rev 47: resolve the manifest's OWN declared
+        // vault-multi-writer rev 47: resolve the manifest's OWN declared
         // signer against the persisted writer set (same pattern + same
         // documented residual as `verifyStoredCheckpoint`/`chainEntries` above).
         const manifestSigner = this.repoFile().writer_set_pin?.writers.find((w) => w.writer_key_id === manifest.writer_key_id)?.signing_pubkey ?? genesis.creator_signing_pubkey;
-        if (!verifyGitvaultObject(manifest, manifestSigner)) {
-            fail("GITVAULT_SIGNATURE_INVALID", `recipient_pin_manifest ${receipt.pin_manifest_version} signature does not verify`, "resolving the effective recipient pin manifest", { pin_manifest_version: receipt.pin_manifest_version });
+        if (!verifyVaultObject(manifest, manifestSigner)) {
+            fail("VAULT_SIGNATURE_INVALID", `recipient_pin_manifest ${receipt.pin_manifest_version} signature does not verify`, "resolving the effective recipient pin manifest", { pin_manifest_version: receipt.pin_manifest_version });
         }
         const pinnedFingerprintOf = new Map(manifest.pins.map((p) => [p.principal_id, p.ek_fingerprint]));
         return { pinManifestVersion: receipt.pin_manifest_version, pinManifestSha256: receipt.stored_bytes_sha256, pinnedFingerprintOf };
@@ -3924,17 +3924,17 @@ export class GitvaultVault {
         for (const [principalId, ekFp] of prior.pinnedFingerprintOf) {
             if (updateIds.has(principalId))
                 continue; // replaced below
-            pins.push({ principal_id: principalId, ek_fingerprint: ekFp, pinned_at: formatGitvaultTimestamp(this.now()), confirmed_by: "operator_confirmation", confirmation_receipt_sha256: GITVAULT_ZERO_SHA256_SENTINEL });
+            pins.push({ principal_id: principalId, ek_fingerprint: ekFp, pinned_at: formatVaultTimestamp(this.now()), confirmed_by: "operator_confirmation", confirmation_receipt_sha256: VAULT_ZERO_SHA256_SENTINEL });
         }
         for (const u of updates) {
-            pins.push({ principal_id: u.principal_id, ek_fingerprint: u.ek_fingerprint, pinned_at: formatGitvaultTimestamp(this.now()), confirmed_by: "operator_confirmation", confirmation_receipt_sha256: storedBytesSha256(u.receipt) });
+            pins.push({ principal_id: u.principal_id, ek_fingerprint: u.ek_fingerprint, pinned_at: formatVaultTimestamp(this.now()), confirmed_by: "operator_confirmation", confirmation_receipt_sha256: storedBytesSha256(u.receipt) });
         }
         pins.sort((a, b) => (a.principal_id < b.principal_id ? -1 : a.principal_id > b.principal_id ? 1 : 0));
-        const unsignedManifest = { format: GITVAULT_FORMAT, object_kind: "recipient_pin_manifest", suite: GITVAULT_SUITE, repo_id: this.repoId, pin_manifest_version: nextVersion, base_pin_manifest_sha256: prior.pinManifestSha256, pins, writer_key_id: this.writerKeyId() };
-        const manifest = signGitvaultObject(unsignedManifest, this.signer());
+        const unsignedManifest = { format: VAULT_FORMAT, object_kind: "recipient_pin_manifest", suite: VAULT_SUITE, repo_id: this.repoId, pin_manifest_version: nextVersion, base_pin_manifest_sha256: prior.pinManifestSha256, pins, writer_key_id: this.writerKeyId() };
+        const manifest = signVaultObject(unsignedManifest, this.signer());
         const manifestBytes = storedBytes(manifest);
         const manifestSha = sha256Hex(manifestBytes);
-        const upload = { path: gitvaultPaths.pinManifest(nextVersion), object_kind: "recipient_pin_manifest", object_id: null, bytes: manifestBytes, sha256: manifestSha, size_bytes: String(manifestBytes.length) };
+        const upload = { path: vaultPaths.pinManifest(nextVersion), object_kind: "recipient_pin_manifest", object_id: null, bytes: manifestBytes, sha256: manifestSha, size_bytes: String(manifestBytes.length) };
         return { nextVersion, manifestSha, upload, pins: pins.map((p) => ({ principal_id: p.principal_id, ek_fingerprint: p.ek_fingerprint })) };
     }
     /**
@@ -3949,7 +3949,7 @@ export class GitvaultVault {
      * **This is an ORDINARY admission (`transition: null`) and is therefore
      * itself refused `EPOCH_ROTATION_REQUIRED` while a migration/revocation/
      * exposure condition is outstanding on this vault (D193) — the exact
-     * deadlock the incident behind {@link GitvaultVault.rotateEpoch}'s
+     * deadlock the incident behind {@link Vault.rotateEpoch}'s
      * `pending_confirmations` parameter closes.** When this vault is in that
      * state, fold the receipt into `rotateEpoch({..., pending_confirmations:
      * [{principal_id, ek_fingerprint, receipt}]})` instead of calling this
@@ -3960,7 +3960,7 @@ export class GitvaultVault {
         let conflicts = 0;
         for (;;) {
             const base = await this.materialize();
-            this.assertCallerIsWriter("publishing a recipient_pin_manifest update", conflicts > 0); // gitvault-multi-writer task 5.8
+            this.assertCallerIsWriter("publishing a recipient_pin_manifest update", conflicts > 0); // vault-multi-writer task 5.8
             const prior = await this.loadEffectivePinManifest(base.generation);
             const { nextVersion, manifestSha, upload: manifestUpload, pins } = this.buildPinManifestUpdate(prior, [input]);
             await this.uploadAll([manifestUpload]);
@@ -4008,17 +4008,17 @@ export class GitvaultVault {
      *
      * **`recipient_state_version`/`recipient_revocation_version` are REQUIRED
      * inputs, not discovered here.** The gateway exposes NO general read route
-     * for `internal.gitvault_recipient_state_counters` (D194) — the ONLY
+     * for `internal.vault_recipient_state_counters` (D194) — the ONLY
      * client-visible read of these two org-scoped counters today is the
      * response of `POST …/recipients/:principal_id/key-revocation`
-     * ({@link GitvaultTransport.declareRecipientKeyRevoked}), which is why
+     * ({@link VaultTransport.declareRecipientKeyRevoked}), which is why
      * {@link rotateEpochForKeyRevocation} (below) is the one fully
      * self-contained entry point. For `member_removed` / `elective_rekey` /
      * `epoch_secret_exposed`, a caller that does not already know the current
      * counter pair cannot discover it from any shipped gateway route — this
      * is a confirmed gap in the live gateway (verified against
-     * `packages/gateway/src/services/gitvault/reads.ts:getVaultRecord` and
-     * every `routes/gitvault*.ts` handler, not inferred), not a client
+     * `packages/gateway/src/services/vault/reads.ts:getVaultRecord` and
+     * every `routes/vault*.ts` handler, not inferred), not a client
      * limitation this SDK can work around. Passing a stale/guessed pair fails
      * safely: the admission fence's D194 frozen-counter comparison refuses
      * `RECIPIENT_SET_MISMATCH` rather than silently canonizing against wrong
@@ -4041,7 +4041,7 @@ export class GitvaultVault {
      * PREDECESSOR manifest, unchanged. They land in
      * `excluded_unconfirmed_principal_ids` here (same as without folding) and
      * become eligible starting at the NEXT rotation, once this manifest is
-     * the admitted predecessor. See {@link GitvaultRotationResult.pin_manifest_published}.
+     * the admitted predecessor. See {@link VaultRotationResult.pin_manifest_published}.
      *
      * **Honest residual — this does not rescue a vault with ZERO ever-
      * confirmed principals.** If `included` would be empty even with the
@@ -4059,7 +4059,7 @@ export class GitvaultVault {
         let conflicts = 0;
         for (;;) {
             const base = await this.materialize();
-            this.assertCallerIsWriter("driving an epoch rotation", conflicts > 0); // gitvault-multi-writer task 5.8
+            this.assertCallerIsWriter("driving an epoch rotation", conflicts > 0); // vault-multi-writer task 5.8
             const repo = this.repoFile();
             const currentEpoch = base.head?.epoch ?? this.epoch();
             const newEpoch = nextEpoch(currentEpoch);
@@ -4077,7 +4077,7 @@ export class GitvaultVault {
             const envelopeRecipients = await this.transport.listEnvelopeRecipients({ repo_id: this.repoId });
             const desired = envelopeRecipients.desired;
             if (!desired) {
-                fail("GITVAULT_DESIRED_STATE_UNAVAILABLE", "the gateway did not report desired-recipient state (desired[]) for this vault — an epoch rotation cannot compute its H-partition without it", "computing the epoch-rotation H-partition");
+                fail("VAULT_DESIRED_STATE_UNAVAILABLE", "the gateway did not report desired-recipient state (desired[]) for this vault — an epoch rotation cannot compute its H-partition without it", "computing the epoch-rotation H-partition");
             }
             const pinManifest = await this.loadEffectivePinManifest(base.generation);
             // The vault record: `writer_set` (the chain's active writers, by
@@ -4155,7 +4155,7 @@ export class GitvaultVault {
                 included.push({ principal_id: d.principal_id, ek_fingerprint: d.ek_fingerprint, public_key: pub });
             }
             if (pinBlocked.length > 0) {
-                fail("GITVAULT_ROTATION_BLOCKED_PIN_MISMATCH", `${pinBlocked.length} principal(s) have a live pin that disagrees with their current directory key and cannot be safely included or excluded under the protocol's own H-partition rules — run the /repin ceremony for each, then retry: ${pinBlocked.map((p) => p.principal_id).join(", ")}`, "computing the epoch-rotation H-partition", { blocked: pinBlocked });
+                fail("VAULT_ROTATION_BLOCKED_PIN_MISMATCH", `${pinBlocked.length} principal(s) have a live pin that disagrees with their current directory key and cannot be safely included or excluded under the protocol's own H-partition rules — run the /repin ceremony for each, then retry: ${pinBlocked.map((p) => p.principal_id).join(", ")}`, "computing the epoch-rotation H-partition", { blocked: pinBlocked });
             }
             if (options.reason === "elective_rekey" && (excludedKeyless.length > 0 || excludedUnconfirmed.length > 0)) {
                 fail("EPOCH_ROTATION_INCOMPLETE_ENROLLMENT", `reason:"elective_rekey" refuses a target set that is a proper subset of the vault's current actual coverage — ${excludedKeyless.length} keyless, ${excludedUnconfirmed.length} unconfirmed`, "computing the epoch-rotation H-partition", { excluded_keyless_principal_ids: excludedKeyless, excluded_unconfirmed_principal_ids: excludedUnconfirmed });
@@ -4178,7 +4178,7 @@ export class GitvaultVault {
                 excluded_keyless_principal_ids: excludedKeyless,
                 excluded_unconfirmed_principal_ids: excludedUnconfirmed,
             });
-            // gitvault-multi-writer (task 5.9, D6/D227) — fold in a writer_set_update
+            // vault-multi-writer (task 5.9, D6/D227) — fold in a writer_set_update
             // whenever the gateway's own blocked set (`ineligible_members`, read
             // fresh) is non-empty. This is what closes D6's "ordinary
             // admissions... refuse EPOCH_ROTATION_REQUIRED... until a rotate_epoch
@@ -4209,7 +4209,7 @@ export class GitvaultVault {
             let writerSetUpdate = null;
             if (ineligible.length > 0) {
                 if (!writerPin) {
-                    fail("GITVAULT_WRITER_STATE_UNAVAILABLE", "no locally verified writer_set_pin for this vault — the chain must be verified (materialize/verifyToNewest) before a writer_set_update can be built against a known base writer set", "computing the writer_set_update");
+                    fail("VAULT_WRITER_STATE_UNAVAILABLE", "no locally verified writer_set_pin for this vault — the chain must be verified (materialize/verifyToNewest) before a writer_set_update can be built against a known base writer set", "computing the writer_set_update");
                 }
                 const predecessorState = { version: writerPin.version, writers: writerPin.writers, sha256: writerPin.sha256, burnedWriterKeyIds: new Set(), consumedHandoffIds: new Set(), retiredWriters: writerPin.retired_writers ?? [] };
                 // A rotation's own top-level `reason:"epoch_secret_exposed"` is the
@@ -4246,7 +4246,7 @@ export class GitvaultVault {
             // `false`; omitting the field is refused RECIPIENT_SET_MISMATCH.
             const migrationBootstrap = false;
             const descriptorFields = {
-                format: GITVAULT_FORMAT, object_kind: "rotation_attempt_descriptor", suite: GITVAULT_SUITE,
+                format: VAULT_FORMAT, object_kind: "rotation_attempt_descriptor", suite: VAULT_SUITE,
                 repo_id: this.repoId, base_head_sha256: base.head_sha256, new_epoch: newEpoch,
                 recipient_state_version: options.recipient_state_version, recipient_revocation_version: options.recipient_revocation_version,
                 migration_bootstrap: migrationBootstrap,
@@ -4256,7 +4256,7 @@ export class GitvaultVault {
                 ...(writerSetUpdate ? { writer_revocation_version: vaultRecord.writer_revocation_version ?? "0", writer_set_base_sha256: writerSetUpdate.base_sha256, writer_set_next_sha256: writerSetUpdate.next_sha256 } : {}),
             };
             const attemptCommitment = attemptKeyCommitment(kE, this.repoId, newEpoch, descriptorFields);
-            const signedDescriptor = signGitvaultObject({ ...descriptorFields, attempt_key_commitment: attemptCommitment }, this.signer());
+            const signedDescriptor = signVaultObject({ ...descriptorFields, attempt_key_commitment: attemptCommitment }, this.signer());
             const rotationId = computeRotationId(signedDescriptor);
             const attemptOut = await this.transport.createRotationAttempt({ repo_id: this.repoId, descriptor: signedDescriptor });
             if (attemptOut.rotation_id !== rotationId) {
@@ -4265,11 +4265,11 @@ export class GitvaultVault {
             // Seal one key_envelope per included recipient, all from the SAME kE (D200's global one-key property depends on this).
             const sealedReceipts = [];
             const envelopeUploads = [];
-            const nowIso = formatGitvaultTimestamp(this.now());
+            const nowIso = formatVaultTimestamp(this.now());
             for (const p of included) {
                 const sealed = await sealKeyEnvelope({ k_repo: kE, repo_id: this.repoId, epoch: newEpoch, recipient_public_key: p.public_key, signer: this.signingKeypair(), created_at: nowIso, rotation_id: rotationId });
                 sealedReceipts.push({ principal_id: p.principal_id, envelope: sealed.receipt });
-                envelopeUploads.push({ path: gitvaultPaths.envelope(newEpoch, p.ek_fingerprint, rotationId), object_kind: "key_envelope", object_id: null, bytes: sealed.stored_bytes, sha256: sealed.stored_bytes_sha256, size_bytes: sealed.size_bytes });
+                envelopeUploads.push({ path: vaultPaths.envelope(newEpoch, p.ek_fingerprint, rotationId), object_kind: "key_envelope", object_id: null, bytes: sealed.stored_bytes, sha256: sealed.stored_bytes_sha256, size_bytes: sealed.size_bytes });
             }
             if (envelopeUploads.length > 0)
                 await this.uploadAll(envelopeUploads);
@@ -4282,7 +4282,7 @@ export class GitvaultVault {
                 pin_manifest_sha256: pinManifest.pinManifestSha256, target_partition_digest: targetPartitionDigest,
                 epoch_key_commitment: epochKeyCommitmentValue, excluded_keyless_principal_ids: excludedKeyless, excluded_unconfirmed_principal_ids: excludedUnconfirmed,
                 recipient_authority_attestation: null, envelopes: sealedReceipts,
-                // gitvault-multi-writer (task 5.9, D227): present IFF this rotation ALSO removes one or more writers.
+                // vault-multi-writer (task 5.9, D227): present IFF this rotation ALSO removes one or more writers.
                 ...(writerSetUpdate ? { writer_set_update: writerSetUpdate } : {}),
             };
             // D209 (rev 44) — round-trip THIS principal's own new-epoch
@@ -4304,7 +4304,7 @@ export class GitvaultVault {
             // rotation committed server-side that even its own writer cannot
             // read back. A round-trip failure THROWS
             // (openEpochRotationForRecipient's own error framing — e.g.
-            // GITVAULT_EPOCH_NOT_OPENABLE / EPOCH_KEY_COMMITMENT_MISMATCH — never
+            // VAULT_EPOCH_NOT_OPENABLE / EPOCH_KEY_COMMITMENT_MISMATCH — never
             // a bare AEAD failure); this call never emits a false attestation.
             const identity = this.keystore.readIdentity();
             const ownKeypair = identity ? this.keystore.encryptionKeypair(identity) : null;
@@ -4320,7 +4320,7 @@ export class GitvaultVault {
                     own_encryption_keypair: ownKeypair,
                     writer_signing_public_key: this.signingKeypair().public_key,
                     get_envelope_bytes: (path) => this.transport.getObject({ repo_id: this.repoId, path }),
-                    envelope_path: (epoch, fp, rid) => gitvaultPaths.envelope(epoch, fp, rid),
+                    envelope_path: (epoch, fp, rid) => vaultPaths.envelope(epoch, fp, rid),
                 });
                 // openEpochRotationForRecipient already recomputes epoch_key_commitment
                 // from the opened plaintext and compares it to payloadBase's own
@@ -4334,7 +4334,7 @@ export class GitvaultVault {
                     chain_verified_to_generation: base.generation,
                     decryptable_to_generation: generation,
                     opened_fingerprint: ownFingerprint,
-                    reader_entrypoint: gitvaultReaderEntrypoint("openEpochRotationForRecipient"),
+                    reader_entrypoint: vaultReaderEntrypoint("openEpochRotationForRecipient"),
                 };
                 selfCheck = "passed";
             }
@@ -4406,12 +4406,12 @@ export class GitvaultVault {
             if (pinManifestFold) {
                 this.keystore.updateRepo(this.repoId, { known_pin_manifest: { pin_manifest_version: pinManifestFold.nextVersion, stored_bytes_sha256: pinManifestFold.manifestSha, pins: pinManifestFold.pins } });
             }
-            // gitvault-multi-writer (task 5.9) — the SAME local-pin advance
+            // vault-multi-writer (task 5.9) — the SAME local-pin advance
             // #publishAddWriterKeyTransition performs on ITS success path: this
             // head just admitted a writer_set_update, so the locally-pinned
             // writer set is now stale until refreshed here.
             if (writerSetUpdate) {
-                this.keystore.updateRepo(this.repoId, { writer_set_pin: { version: writerSetUpdate.next_version, sha256: writerSetUpdate.next_sha256, writers: [...writerSetUpdate.writers], pinned_at: formatGitvaultTimestamp(this.now()) } });
+                this.keystore.updateRepo(this.repoId, { writer_set_pin: { version: writerSetUpdate.next_version, sha256: writerSetUpdate.next_sha256, writers: [...writerSetUpdate.writers], pinned_at: formatVaultTimestamp(this.now()) } });
             }
             return {
                 outcome: "admitted", generation, head_sha256: admitted.head_sha256, new_epoch: newEpoch, rotation_id: rotationId, reason: options.reason,
@@ -4425,14 +4425,14 @@ export class GitvaultVault {
     }
     /**
      * The writer-capable rotation that completes an org membership removal
-     * (gitvault-multi-writer D6: "`member_removed` keeps its automatic
+     * (vault-multi-writer D6: "`member_removed` keeps its automatic
      * writer-capable path"). The removal itself already advanced the org's
      * D194 counters and flipped the member to `pending_removal`, so there is
      * nothing to declare: read the counters off the envelope-recipients read
      * (the same read the H-partition uses) and rotate under
      * `reason:"member_removed"`, which needs `gitvault.writer` only — any
      * surviving writer can run it, no owner step-up. Refuses
-     * `GITVAULT_ROTATION_COUNTERS_UNAVAILABLE` on a gateway that does not yet
+     * `VAULT_ROTATION_COUNTERS_UNAVAILABLE` on a gateway that does not yet
      * carry the counters on that read.
      */
     async rotateEpochForMemberRemoval(options = {}) {
@@ -4440,7 +4440,7 @@ export class GitvaultVault {
         const state = recipients.recipient_state_version;
         const revocation = recipients.recipient_revocation_version;
         if (typeof state !== "string" || typeof revocation !== "string") {
-            fail("GITVAULT_ROTATION_COUNTERS_UNAVAILABLE", "the gateway did not report the org's rotation counters on the envelope-recipients read — a member-removal rotation cannot be fenced without them; an owner can run `run402 repos access revoke-key <principal_id>` instead", "reading the rotation counters");
+            fail("VAULT_ROTATION_COUNTERS_UNAVAILABLE", "the gateway did not report the org's rotation counters on the envelope-recipients read — a member-removal rotation cannot be fenced without them; an owner can run `run402 repos access revoke-key <principal_id>` instead", "reading the rotation counters");
         }
         return this.rotateEpoch({ reason: "member_removed", recipient_state_version: state, recipient_revocation_version: revocation, client_idempotency_key: options.client_idempotency_key });
     }
@@ -4454,7 +4454,7 @@ export class GitvaultVault {
         const counters = await this.transport.declareRecipientKeyRevoked({ repo_id: this.repoId, principal_id: principalId });
         return this.rotateEpoch({ reason: "recipient_key_revoked", recipient_state_version: counters.recipient_state_version, recipient_revocation_version: counters.recipient_revocation_version, client_idempotency_key: options.client_idempotency_key });
     }
-    // ── writer activation (gitvault-multi-writer task 5.6, design D4/D5) ──────
+    // ── writer activation (vault-multi-writer task 5.6, design D4/D5) ──────
     /**
      * Submit a REF-NEUTRAL `add_writer_key{authorization.kind:"handoff"}`
      * activation head — no ref/checkpoint/repair changes ride it (protocol
@@ -4484,13 +4484,13 @@ export class GitvaultVault {
      */
     async submitWriterActivationHead(input) {
         return this.#publishAddWriterKeyTransition(input.addedWriterKeyId, (pin) => buildAddWriterKeyActivationPayload(this.repoId, pin, { writer_key_id: input.addedWriterKeyId, signing_pubkey: input.addedSigningPubkeyB64u, principal_id: input.addedPrincipalId }, input.handoffId, input.grant, input.acceptance), "submitting a writer activation head", 
-        // gitvault-multi-writer task 5.8: the handoff door is signed by the
+        // vault-multi-writer task 5.8: the handoff door is signed by the
         // ADDED key itself, which is by design NOT YET a writer — the pre-
         // check must be SKIPPED here, or this call could never succeed.
         false);
     }
     /**
-     * gitvault-multi-writer (task 5.7) — the "writer"-door twin of {@link
+     * vault-multi-writer (task 5.7) — the "writer"-door twin of {@link
      * submitWriterActivationHead}: an ALREADY-ACTIVE writer (this vault
      * session's own key) admits `input`, an eligible org member with a
      * published signing key but no writer standing yet, via a fresh
@@ -4500,8 +4500,8 @@ export class GitvaultVault {
      * branch), re-verified admission-side by `checkTransitionAdmissible`.
      * Task 5.8 adds the SAME local pre-check every other head-signing path
      * gets: if THIS session's own key is not (or is no longer) an active
-     * writer, refuse EARLY and LOCALLY (`GITVAULT_WRITER_NOT_ADMITTED` /
-     * `GITVAULT_WRITER_REMOVED`) rather than let the head reach the gateway
+     * writer, refuse EARLY and LOCALLY (`VAULT_WRITER_NOT_ADMITTED` /
+     * `VAULT_WRITER_REMOVED`) rather than let the head reach the gateway
      * only to be refused there — redundant with `reconcileWriterAdmissions`'s
      * own upfront gate for that caller, but this method is public and a
      * direct caller should get the same fast, specific refusal.
@@ -4533,7 +4533,7 @@ export class GitvaultVault {
                 this.assertCallerIsWriter(errorContext, conflicts > 0);
             const pin = this.repoFile().writer_set_pin;
             if (!pin) {
-                fail("GITVAULT_WRITER_STATE_UNAVAILABLE", "no locally verified writer_set_pin for this vault — the chain must be verified (materialize/verifyToNewest) before an activation head can be built against a known base writer set", errorContext);
+                fail("VAULT_WRITER_STATE_UNAVAILABLE", "no locally verified writer_set_pin for this vault — the chain must be verified (materialize/verifyToNewest) before an activation head can be built against a known base writer set", errorContext);
             }
             if (pin.writers.some((w) => w.writer_key_id === addedWriterKeyId)) {
                 return { outcome: "already_admitted", generation: base.generation };
@@ -4554,7 +4554,7 @@ export class GitvaultVault {
             }
             if (published.outcome === "dry_run")
                 fail("GIT_COMMAND_FAILED", "internal: #publishAddWriterKeyTransition() received a dry-run result it never requested", errorContext);
-            this.keystore.updateRepo(this.repoId, { writer_set_pin: { version: nextState.version, sha256: nextState.sha256, writers: [...nextState.writers], pinned_at: formatGitvaultTimestamp(this.now()) } });
+            this.keystore.updateRepo(this.repoId, { writer_set_pin: { version: nextState.version, sha256: nextState.sha256, writers: [...nextState.writers], pinned_at: formatVaultTimestamp(this.now()) } });
             return {
                 outcome: "activated",
                 result: { generation: published.generation, head_sha256: published.head_sha256, head: published.head, admission_record_sha256: published.admission_record_sha256, capture_receipt: published.capture_receipt, form: published.form, conflicts_retried: conflicts, refs: published.refs, checkpoint_staleness: this.checkpointStalenessNow(published.generation) },
@@ -4562,7 +4562,7 @@ export class GitvaultVault {
         }
     }
     /**
-     * gitvault-multi-writer (task 5.7) — the vault's OWN writer-admission
+     * vault-multi-writer (task 5.7) — the vault's OWN writer-admission
      * reconcile: reads `pending_writers[]` off the vault record (eligible org
      * members with no writer standing yet), resolves each candidate's
      * published signing key off the org's encryption-key directory (the SAME
@@ -4580,7 +4580,7 @@ export class GitvaultVault {
      * a session that reached this call already pushed successfully as an
      * active writer in every wired call site (push/snapshot/deploy) OR is a
      * member that simply is not one yet (session-start/read) — the SAME
-     * "not yet admitted" case {@link Gitvault.push}'s own pre-push check
+     * "not yet admitted" case {@link Repos.capture}'s own pre-push check
      * (task 5.8) names, not a new refusal shape. Returns `{eligible: false}`
      * with every other field empty (never throws) for that case: every OTHER
      * `pending_writers[]` entry would fail identically, so there is nothing
@@ -4641,7 +4641,7 @@ export class GitvaultVault {
      */
     async repair(input) {
         const newest = await this.verifyToNewest();
-        // gitvault-multi-writer task 5.8 — repair requires OWNER+step-up
+        // vault-multi-writer task 5.8 — repair requires OWNER+step-up
         // server-side (`authority.repair`), but that is layered ON TOP of the
         // baseline writer requirement every head needs (`authority.writer`,
         // confirmed against the gateway's own admission fixture: an owner who
@@ -4660,8 +4660,8 @@ export class GitvaultVault {
         // The base head's carriers were sealed by the writer that carried THAT
         // head (rev 47: any admitted writer, not only the creator).
         const writerKey = this.writerKeyForHead(baseEntry.head, newest.genesis.creator_signing_pubkey);
-        const baseRefState = await this.openCarrier("ref_state", baseEntry.head.ref_state, gitvaultPaths.refState(baseEntry.head.ref_state.object_id), writerKey);
-        const baseRoots = await this.openCarrier("retention_roots", baseEntry.head.retention_roots, gitvaultPaths.retentionRoots(baseEntry.head.retention_roots.object_id), writerKey);
+        const baseRefState = await this.openCarrier("ref_state", baseEntry.head.ref_state, vaultPaths.refState(baseEntry.head.ref_state.object_id), writerKey);
+        const baseRoots = await this.openCarrier("retention_roots", baseEntry.head.retention_roots, vaultPaths.retentionRoots(baseEntry.head.retention_roots.object_id), writerKey);
         const repairGen = nextGeneration(newest.generation);
         const repairedRefs = baseRefState.refs;
         const repairedTips = Object.values(repairedRefs);
@@ -4670,7 +4670,7 @@ export class GitvaultVault {
             const entry = chain.get(bigIntToGeneration(g));
             let state;
             try {
-                state = await this.openCarrier("ref_state", entry.head.ref_state, gitvaultPaths.refState(entry.head.ref_state.object_id), writerKey);
+                state = await this.openCarrier("ref_state", entry.head.ref_state, vaultPaths.refState(entry.head.ref_state.object_id), writerKey);
             }
             catch {
                 continue; // an unusable superseded ref_state preserves nothing it cannot name (reason unusable_ref_state)
@@ -4689,8 +4689,8 @@ export class GitvaultVault {
                 }
             }
         }
-        if (added.length > GITVAULT_MAX_REPAIR_ADDED_ROOTS)
-            fail("REF_STATE_LIMIT_EXCEEDED", `${added.length} repair-added roots exceed the ${GITVAULT_MAX_REPAIR_ADDED_ROOTS} bound`, "preparing repair");
+        if (added.length > VAULT_MAX_REPAIR_ADDED_ROOTS)
+            fail("REF_STATE_LIMIT_EXCEEDED", `${added.length} repair-added roots exceed the ${VAULT_MAX_REPAIR_ADDED_ROOTS} bound`, "preparing repair");
         const roots = evolveRetentionRoots(baseRoots.roots, { generation: repairGen, dropped: added });
         const refState = this.buildRefState(repairGen, repairedRefs, baseRefState.head_target);
         const rootsObj = this.buildRetentionRoots(repairGen, roots, null);
@@ -4735,13 +4735,13 @@ export class GitvaultVault {
         const stop = generationToBigInt(baseGeneration);
         while (g >= stop) {
             const gen = bigIntToGeneration(g);
-            const bytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.head(gen) });
+            const bytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.head(gen) });
             if (!bytes || sha256Hex(bytes) !== expected)
-                fail("CHAIN_BROKEN", `head ${gen} no longer matches the verified chain`, "re-reading gitvault chain", { generation: gen });
-            const head = parseGitvaultStrict(new TextDecoder().decode(bytes));
+                fail("CHAIN_BROKEN", `head ${gen} no longer matches the verified chain`, "re-reading vault chain", { generation: gen });
+            const head = parseVaultStrict(new TextDecoder().decode(bytes));
             if (transitions === "refuse") {
                 if (head.transition !== null)
-                    fail("UPGRADE_REQUIRED", "a repair must not cross an admitted transition", "re-reading gitvault chain", { generation: gen });
+                    fail("UPGRADE_REQUIRED", "a repair must not cross an admitted transition", "re-reading vault chain", { generation: gen });
             }
             else {
                 assertNoTransition(head);
@@ -4758,10 +4758,10 @@ export class GitvaultVault {
      * `targetRepoDir` (an initialized repository), then verify every canonical
      * ref + the HEAD target resolves. Returns the materialized refs.
      *
-     * Design D5 (gitvault-client-round-trips): incremental above the local
+     * Design D5 (vault-client-round-trips): incremental above the local
      * `restored_through` marker (this target directory's own local git
-     * config, read/written by {@link readGitvaultRestoreMarker}/{@link
-     * writeGitvaultRestoreMarker}) — replaying only the WAL packs of
+     * config, read/written by {@link readVaultRestoreMarker}/{@link
+     * writeVaultRestoreMarker}) — replaying only the WAL packs of
      * generations above it — WHEN the walk from newest back to the marker is
      * plain WAL the entire way. The moment that walk crosses a
      * checkpoint-bearing, repair, or transition head (checked BEFORE
@@ -4773,12 +4773,12 @@ export class GitvaultVault {
      * paths; the marker only advances after they both succeed.
      */
     async restoreObjectsInto(targetRepoDir, reuse) {
-        // gitvault-delta-fetch: the marker is read BEFORE materialize so the
+        // vault-delta-fetch: the marker is read BEFORE materialize so the
         // state read can carry THIS git dir's applied position as `since` —
         // see tryStateFastPath's own comment on why the pin is the wrong
         // position for a standing clone.
         //
-        // gitvault-session-state-reuse: `reuse` lets a caller that ALREADY
+        // vault-session-state-reuse: `reuse` lets a caller that ALREADY
         // materialized state for this same target directory — using the SAME
         // marker `since` this method would itself read — hand that response
         // in directly, skipping this method's own state read entirely (the
@@ -4791,9 +4791,9 @@ export class GitvaultVault {
         // session, a stale handoff) falls through to this method's own
         // `materialize()` exactly as if `reuse` had never been passed. A wrong
         // reuse therefore costs one extra read, never a wrong result.
-        const marker = await readGitvaultRestoreMarker(targetRepoDir);
+        const marker = await readVaultRestoreMarker(targetRepoDir);
         const markerMatches = (a, b) => a === null ? b === null : b !== null && a.generation === b.generation && a.head_sha256 === b.head_sha256;
-        // gitvault-restore-recipe design D2/D6: a marker-absent materialize is,
+        // vault-restore-recipe design D2/D6: a marker-absent materialize is,
         // by construction, the wholesale shape (a fresh target has nothing to
         // replay incrementally) — declare restore intent here so a capable
         // gateway's plan rides THIS read rather than a second one. Mirrors the
@@ -4811,16 +4811,16 @@ export class GitvaultVault {
         // Already up to date locally: no pack fetch, not even a walk — only the
         // (entirely local) coverage + retained-refs bookkeeping below runs.
         if (marker && marker.generation === newest.generation && marker.head_sha256 === newest.head_sha256) {
-            const tips = GitvaultVault.coverageTips(newest.refs, newest.roots, newest.head_target);
+            const tips = Vault.coverageTips(newest.refs, newest.roots, newest.head_target);
             const present = await hasObjects(targetRepoDir, tips);
             for (const t of tips) {
                 if (!present.has(t))
-                    fail("CHAIN_UNUSABLE", `covered tip ${t} does not resolve after restore`, "restoring gitvault objects", { oid: t });
+                    fail("CHAIN_UNUSABLE", `covered tip ${t} does not resolve after restore`, "restoring vault objects", { oid: t });
             }
             const retained_refs = await reconcileRetainedTipRefs(targetRepoDir, { refs: newest.refs, roots: newest.roots, head_target: newest.head_target });
             return { refs: newest.refs, head_target: newest.head_target, generation: newest.generation, retained_refs };
         }
-        // gitvault-restore-recipe (design D1-D6): consume a plan that already
+        // vault-restore-recipe (design D1-D6): consume a plan that already
         // rode this method's OWN materialize() (the `restore: true` request
         // above, or the reused list-phase read) BEFORE paying for the backward
         // walk below at all. `tryConsumeRestorePlan` verifies from scratch and
@@ -4841,7 +4841,7 @@ export class GitvaultVault {
         const heads = [];
         let cur = newest.head;
         let incremental = marker !== null;
-        // gitvault-clone-scaling (bench P2): the backward walk's head PATHS are
+        // vault-clone-scaling (bench P2): the backward walk's head PATHS are
         // all derivable up front (generation N−1, N−2, …) — only each head's
         // expected hash arrives chain-sequentially. Same fetch-concurrent /
         // verify-ordered split as the forward walk: page-sized windows of
@@ -4880,7 +4880,7 @@ export class GitvaultVault {
             if (lo < 1n)
                 lo = 1n;
             nextWindow = nextWindow * 4n;
-            const pageCap = BigInt(GITVAULT_MAX_HEADS_PER_LISTING_PAGE);
+            const pageCap = BigInt(VAULT_MAX_HEADS_PER_LISTING_PAGE);
             if (nextWindow > pageCap)
                 nextWindow = pageCap;
             prefetchFloor = lo;
@@ -4905,7 +4905,7 @@ export class GitvaultVault {
                 incremental = false;
                 heads.length = 0;
                 cur = newest.head;
-                // gitvault-restore-recipe (design D1/D2, task 2.1's named fallback
+                // vault-restore-recipe (design D1/D2, task 2.1's named fallback
                 // shape): the marker WAS present when this method's own materialize()
                 // ran, so `restore` was never declared and no plan rode that read —
                 // fetch one now, dedicated, before falling through to the ordinary
@@ -4946,13 +4946,13 @@ export class GitvaultVault {
                 await prefetchBackwardWindow(prevBig);
             const bytes = await this.readCachedHeadBytes(prevGen, cur.prev_sha256);
             if (!bytes || sha256Hex(bytes) !== cur.prev_sha256)
-                fail("CHAIN_BROKEN", `head ${prevGen} does not match the chain during restore`, "restoring gitvault objects");
-            cur = parseGitvaultStrict(new TextDecoder().decode(bytes));
+                fail("CHAIN_BROKEN", `head ${prevGen} does not match the chain during restore`, "restoring vault objects");
+            cur = parseVaultStrict(new TextDecoder().decode(bytes));
         }
         return this.applyRestoreHeads(targetRepoDir, heads, incremental, newest, writerKey, null, null);
     }
     /**
-     * The shared restore tail (gitvault-restore-recipe): apply `heads`'
+     * The shared restore tail (vault-restore-recipe): apply `heads`'
      * checkpoint (if any) + WAL packs into `targetRepoDir`, verify §4.7
      * coverage, reconcile retained refs, and advance the marker — IDENTICALLY
      * whether `heads` came from {@link restoreObjectsInto}'s own backward walk
@@ -4972,10 +4972,10 @@ export class GitvaultVault {
      * packs (`stateDeltaPacks` never carries checkpoint packs — a delta span
      * never crosses a checkpoint boundary). Both are `null` on the ordinary
      * walk path, in which case every line below is byte-identical to the
-     * pre-gitvault-restore-recipe shape.
+     * pre-vault-restore-recipe shape.
      */
     /**
-     * gitvault-multi-writer (rev 47): the key a head's own checkpoint claim set
+     * vault-multi-writer (rev 47): the key a head's own checkpoint claim set
      * and carriers were signed under — the head's writer, resolved against the
      * keystore's persisted `writer_set_pin` (maintained by the chain walk that
      * always precedes a restore), falling back to `fallback` (the genesis
@@ -4990,7 +4990,7 @@ export class GitvaultVault {
         return known.find((w) => w.writer_key_id === head.writer_key_id)?.signing_pubkey ?? fallback;
     }
     async applyRestoreHeads(targetRepoDir, heads, incremental, newest, writerKey, precheckedCheckpoint, planPacks) {
-        // gitvault-clone-scaling (P3): a WHOLESALE walk just stopped at the
+        // vault-clone-scaling (P3): a WHOLESALE walk just stopped at the
         // newest checkpoint-bearing head, or proved there is none back to
         // genesis — that is first-hand checkpoint coverage, and recording it is
         // what makes the NEXT walk's backward window exact instead of a
@@ -4999,7 +4999,7 @@ export class GitvaultVault {
         // at the marker, learns nothing, and skips — `learned` stays null.)
         {
             const stop = heads[0];
-            const learned = stop.checkpoint ? stop.checkpoint.covers_through_generation : !incremental && stop.generation === "0000000000000001" ? GITVAULT_GENESIS_GENERATION : null;
+            const learned = stop.checkpoint ? stop.checkpoint.covers_through_generation : !incremental && stop.generation === "0000000000000001" ? VAULT_GENESIS_GENERATION : null;
             if (learned !== null) {
                 const known = this.repoFile().checkpoint_covers_through ?? null;
                 if (known === null || !/^[0-9a-f]{16}$/.test(known) || generationToBigInt(learned) > generationToBigInt(known)) {
@@ -5012,18 +5012,18 @@ export class GitvaultVault {
         // NEVER falls back to `this.kRepo()`/`this.epoch()` (this principal's
         // CURRENT pointer, which is the NEWEST epoch, not necessarily every
         // historical one a restore spans). `newest.epoch_keys_hex` is the full
-        // map `materialize()` just resolved (throwing `GITVAULT_EPOCH_NOT_OPENABLE`
+        // map `materialize()` just resolved (throwing `VAULT_EPOCH_NOT_OPENABLE`
         // fail-closed if any needed epoch could not be opened), so every lookup
         // below is guaranteed present.
         const kRepoForEpoch = (epoch) => this.epochKeyFor(newest, epoch);
         const first = heads[0];
-        // gitvault-pipelined-restore: per-object settlement when the transport
+        // vault-pipelined-restore: per-object settlement when the transport
         // offers it, the `getObjects` barrier otherwise — pipelining is a
         // wall-clock property, never a correctness dependency, so a transport
         // without the method reproduces today's serial-after-barrier behavior
         // exactly (each per-index promise settles when the whole batch does).
         //
-        // `expected` (gitvault-small-object-inline design D3) is index-aligned
+        // `expected` (vault-small-object-inline design D3) is index-aligned
         // with `paths` — every caller below already knows each object's
         // receipted ciphertext hash BEFORE fetching it, so it rides along here
         // to let an `object-reads`-backed transport verify (and, on a lying
@@ -5040,7 +5040,7 @@ export class GitvaultVault {
                 void p.catch(() => { });
             return perIndex;
         };
-        // gitvault-pipelined-restore D3: the WAL entry list derives from the
+        // vault-pipelined-restore D3: the WAL entry list derives from the
         // already-verified head walk, so its batched download is INITIATED here —
         // before the checkpoint branch — and its (small, many) objects land while
         // the checkpoint downloads, decrypts, and indexes. APPLICATION of WAL
@@ -5050,11 +5050,11 @@ export class GitvaultVault {
         // rotation-spanning restore never reuses one head's epoch for another's
         // pack.
         const walEntries = heads.flatMap((h) => h.wal_entries.map((w) => ({ w, epoch: h.epoch })));
-        // gitvault-delta-fetch: packs the state read already delivered inline
+        // vault-delta-fetch: packs the state read already delivered inline
         // skip the network ENTIRELY — but only after hashing to their carrying
         // head's receipt (a lying delta is a plain miss; the ordinary fetch
         // below reproduces the unbatched behavior for that slot). The buffer is
-        // consumed exactly once. gitvault-restore-recipe extends the SAME
+        // consumed exactly once. vault-restore-recipe extends the SAME
         // short-circuit to `planPacks` (a verified plan's own pack bytes) —
         // checked SECOND so a delta hit never gets shadowed by a plan hit for
         // the same slot (the two never coexist in practice, per `getState`'s
@@ -5081,7 +5081,7 @@ export class GitvaultVault {
         }
         const uncovered = walEntries.map((_, i) => i).filter((i) => !deltaCovered.has(i));
         const walFramesP = (async () => {
-            const fetched = uncovered.length > 0 ? await settled(uncovered.map((i) => gitvaultPaths.wal(walEntries[i].w.object_id)), uncovered.map((i) => walEntries[i].w.ciphertext_sha256)) : [];
+            const fetched = uncovered.length > 0 ? await settled(uncovered.map((i) => vaultPaths.wal(walEntries[i].w.object_id)), uncovered.map((i) => walEntries[i].w.ciphertext_sha256)) : [];
             return walEntries.map((_, i) => (deltaCovered.has(i) ? Promise.resolve(deltaCovered.get(i)) : fetched[uncovered.indexOf(i)]));
         })();
         void walFramesP.catch(() => { });
@@ -5089,27 +5089,27 @@ export class GitvaultVault {
             let claimSet;
             let manifest;
             if (precheckedCheckpoint) {
-                // gitvault-restore-recipe: already fetched + verified (signature,
+                // vault-restore-recipe: already fetched + verified (signature,
                 // cross-equality) by `verifyRestorePlan` against the plan's own
                 // inline bytes — no network read, no re-verify.
                 ({ claimSet, manifest } = precheckedCheckpoint);
             }
             else {
-                const claimBytes = await this.transport.getObject({ repo_id: this.repoId, path: gitvaultPaths.claimSet(first.checkpoint.claim_set.object_id), expected_sha256: first.checkpoint.claim_set.stored_bytes_sha256 });
+                const claimBytes = await this.transport.getObject({ repo_id: this.repoId, path: vaultPaths.claimSet(first.checkpoint.claim_set.object_id), expected_sha256: first.checkpoint.claim_set.stored_bytes_sha256 });
                 if (!claimBytes || sha256Hex(claimBytes) !== first.checkpoint.claim_set.stored_bytes_sha256)
-                    fail("CHECKPOINT_INCOMPLETE", "claim set absent or altered", "restoring gitvault objects");
-                claimSet = parseGitvaultStrict(new TextDecoder().decode(claimBytes));
-                if (!verifyGitvaultObject(claimSet, this.writerKeyForHead(first, writerKey)))
-                    fail("CHECKPOINT_INCOMPLETE", "claim set signature fails", "restoring gitvault objects");
-                manifest = await this.openCarrier("checkpoint_manifest", claimSet.manifest_receipt, gitvaultPaths.checkpointManifest(claimSet.manifest_receipt.object_id), this.writerKeyForHead(first, writerKey), { epoch: first.epoch, k_repo: kRepoForEpoch(first.epoch) });
+                    fail("CHECKPOINT_INCOMPLETE", "claim set absent or altered", "restoring vault objects");
+                claimSet = parseVaultStrict(new TextDecoder().decode(claimBytes));
+                if (!verifyVaultObject(claimSet, this.writerKeyForHead(first, writerKey)))
+                    fail("CHECKPOINT_INCOMPLETE", "claim set signature fails", "restoring vault objects");
+                manifest = await this.openCarrier("checkpoint_manifest", claimSet.manifest_receipt, vaultPaths.checkpointManifest(claimSet.manifest_receipt.object_id), this.writerKeyForHead(first, writerKey), { epoch: first.epoch, k_repo: kRepoForEpoch(first.epoch) });
                 checkClaimSetEquality(claimSet, manifest, first.checkpoint.covers_through_generation);
             }
-            // Design D2 + gitvault-pipelined-restore D1: every checkpoint pack is
+            // Design D2 + vault-pipelined-restore D1: every checkpoint pack is
             // independent — one batched presign for all of them, applied via
             // index-pack strictly in manifest order, PIPELINED: apply(i) awaits
             // bytes(i), so decrypt/verify/index of an early pack overlaps the
             // later packs' downloads. Per-pack verification (AEAD open + plaintext
-            // hash) still completes before any byte reaches git. gitvault-restore-
+            // hash) still completes before any byte reaches git. vault-restore-
             // recipe: a `planPacks` hit skips the fetch for that index entirely —
             // the SAME short-circuit the WAL loop above runs, extended to the
             // checkpoint class (never carried by `stateDeltaPacks`).
@@ -5122,15 +5122,15 @@ export class GitvaultVault {
                 });
             }
             const uncoveredCk = manifest.packs.map((_, i) => i).filter((i) => !checkpointCovered.has(i));
-            const ckFrames = uncoveredCk.length > 0 ? await settled(uncoveredCk.map((i) => gitvaultPaths.checkpointPack(manifest.packs[i].object_id)), uncoveredCk.map((i) => manifest.packs[i].ciphertext_sha256)) : [];
+            const ckFrames = uncoveredCk.length > 0 ? await settled(uncoveredCk.map((i) => vaultPaths.checkpointPack(manifest.packs[i].object_id)), uncoveredCk.map((i) => manifest.packs[i].ciphertext_sha256)) : [];
             for (let i = 0; i < manifest.packs.length; i++) {
                 const p = manifest.packs[i];
                 const frame = checkpointCovered.has(i) ? checkpointCovered.get(i) : ((await ckFrames[uncoveredCk.indexOf(i)]) ?? null);
                 if (!frame)
-                    fail("CHECKPOINT_INCOMPLETE", `checkpoint pack ${p.object_id} absent`, "restoring gitvault objects");
+                    fail("CHECKPOINT_INCOMPLETE", `checkpoint pack ${p.object_id} absent`, "restoring vault objects");
                 const plain = openFrame({ k_obj: deriveObjectKey(kRepoForEpoch(first.epoch), this.repoId, first.epoch, "checkpoint_pack", p.object_id), repo_id: this.repoId, object_kind: "checkpoint_pack", object_id: p.object_id, epoch: first.epoch, frame, expected_ciphertext_sha256: p.ciphertext_sha256 });
                 if (sha256Hex(plain) !== p.plaintext_sha256 || String(plain.length) !== p.plaintext_size_bytes)
-                    fail("CHECKPOINT_INCOMPLETE", `checkpoint pack ${p.object_id} plaintext mismatch`, "restoring gitvault objects");
+                    fail("CHECKPOINT_INCOMPLETE", `checkpoint pack ${p.object_id} plaintext mismatch`, "restoring vault objects");
                 await hardenedGit(targetRepoDir, ["index-pack", "--stdin", "--strict"], { input: plain });
             }
         }
@@ -5144,20 +5144,20 @@ export class GitvaultVault {
             const { w, epoch } = walEntries[i];
             const frame = (await walFrames[i]) ?? null;
             if (!frame)
-                fail("CHAIN_UNUSABLE", `WAL pack ${w.object_id} absent`, "restoring gitvault objects");
+                fail("CHAIN_UNUSABLE", `WAL pack ${w.object_id} absent`, "restoring vault objects");
             const plain = openFrame({ k_obj: deriveObjectKey(kRepoForEpoch(epoch), this.repoId, epoch, "wal_pack", w.object_id), repo_id: this.repoId, object_kind: "wal_pack", object_id: w.object_id, epoch, frame, expected_ciphertext_sha256: w.ciphertext_sha256 });
             await hardenedGit(targetRepoDir, ["index-pack", "--stdin", "--strict"], { input: plain });
         }
         // the §4.7 coverage set — canonical refs ∪ unexpired roots ∪ the HEAD target — must all resolve.
-        // ONE batched git invocation for the whole set (gitvault-delta-fetch
+        // ONE batched git invocation for the whole set (vault-delta-fetch
         // task 3.1) — identical every-tip-must-resolve semantics, one process
         // instead of one per tip.
         {
-            const tips = GitvaultVault.coverageTips(newest.refs, newest.roots, newest.head_target);
+            const tips = Vault.coverageTips(newest.refs, newest.roots, newest.head_target);
             const present = await hasObjects(targetRepoDir, tips);
             for (const t of tips) {
                 if (!present.has(t))
-                    fail("CHAIN_UNUSABLE", `covered tip ${t} does not resolve after restore`, "restoring gitvault objects", { oid: t });
+                    fail("CHAIN_UNUSABLE", `covered tip ${t} does not resolve after restore`, "restoring vault objects", { oid: t });
             }
         }
         // clone-installs-retained-refs (D2): every retained tip just restored
@@ -5170,21 +5170,21 @@ export class GitvaultVault {
         // (a crash or throw anywhere above) leaves the marker unadvanced, so the
         // next fetch simply repeats this same range; applying an already-applied
         // WAL pack again is the existing, already-safe wholesale behavior.
-        await writeGitvaultRestoreMarker(targetRepoDir, newest.generation, newest.head_sha256);
+        await writeVaultRestoreMarker(targetRepoDir, newest.generation, newest.head_sha256);
         return { refs: newest.refs, head_target: newest.head_target, generation: newest.generation, retained_refs };
     }
     /**
      * `newest.epoch_keys_hex[epoch]`, decoded — the D194 per-carrying-head key
      * lookup shared by {@link applyRestoreHeads} and {@link verifyRestorePlan}.
      * `newest.epoch_keys_hex` is the FULL map `materialize()` resolved
-     * (throwing `GITVAULT_EPOCH_NOT_OPENABLE` fail-closed if any needed epoch
+     * (throwing `VAULT_EPOCH_NOT_OPENABLE` fail-closed if any needed epoch
      * could not be opened), so every lookup through this helper is guaranteed
      * present.
      */
     epochKeyFor(newest, epoch) {
         const hex = newest.epoch_keys_hex[epoch];
         if (!hex)
-            fail("GITVAULT_EPOCH_NOT_OPENABLE", `no locally known key for epoch ${epoch} while restoring objects`, "restoring gitvault objects", { epoch });
+            fail("VAULT_EPOCH_NOT_OPENABLE", `no locally known key for epoch ${epoch} while restoring objects`, "restoring vault objects", { epoch });
         return hexToBytes(hex);
     }
     /**
@@ -5214,8 +5214,8 @@ export class GitvaultVault {
         // fail its OWN element, never abort the whole computation, and this
         // function's contract is "any bad element disqualifies the WHOLE plan."
         // The try/catch below still stands, to catch the genuine exceptions
-        // `parseGitvaultStrict`/`decodeCarrierFrame`/`checkClaimSetEquality`/
-        // `verifyGitvaultObject` can raise (a `fail()`-thrown `Run402Error`, or a
+        // `parseVaultStrict`/`decodeCarrierFrame`/`checkClaimSetEquality`/
+        // `verifyVaultObject` can raise (a `fail()`-thrown `Run402Error`, or a
         // strict-parse rejection) — those are real errors, just ones this method
         // treats as "the plan didn't verify" rather than propagating.
         try {
@@ -5225,7 +5225,7 @@ export class GitvaultVault {
             for (const h of plan.heads) {
                 if (sha256Hex(h.stored_bytes) !== h.stored_bytes_sha256)
                     return null; // self-hash mismatch
-                const head = parseGitvaultStrict(new TextDecoder().decode(h.stored_bytes));
+                const head = parseVaultStrict(new TextDecoder().decode(h.stored_bytes));
                 if (head.generation !== h.generation)
                     return null; // generation mismatch
                 parsed.push({ generation: h.generation, bytes: h.stored_bytes, head });
@@ -5248,7 +5248,7 @@ export class GitvaultVault {
                     return null; // chain link broken
             }
             const first = parsed[0];
-            if (plan.boundary_generation === GITVAULT_GENESIS_GENERATION) {
+            if (plan.boundary_generation === VAULT_GENESIS_GENERATION) {
                 if (first.generation !== "0000000000000001")
                     return null; // genesis boundary mismatch
                 const { sha256: genesisSha } = await this.genesis();
@@ -5265,7 +5265,7 @@ export class GitvaultVault {
             if (!this.walkPrefetch)
                 this.walkPrefetch = new Map();
             for (const p of parsed)
-                this.walkPrefetch.set(gitvaultPaths.head(p.generation), p.bytes);
+                this.walkPrefetch.set(vaultPaths.head(p.generation), p.bytes);
             let checkpoint = null;
             if (first.head.checkpoint) {
                 if (!plan.checkpoint)
@@ -5275,8 +5275,8 @@ export class GitvaultVault {
                     return null; // claim set id mismatch
                 if (sha256Hex(plan.checkpoint.claim_set.stored_bytes) !== claimReceipt.stored_bytes_sha256)
                     return null; // claim set hash mismatch
-                const claimSet = parseGitvaultStrict(new TextDecoder().decode(plan.checkpoint.claim_set.stored_bytes));
-                if (!verifyGitvaultObject(claimSet, this.writerKeyForHead(first.head, writerKey)))
+                const claimSet = parseVaultStrict(new TextDecoder().decode(plan.checkpoint.claim_set.stored_bytes));
+                if (!verifyVaultObject(claimSet, this.writerKeyForHead(first.head, writerKey)))
                     return null; // claim set signature fails
                 if (claimSet.manifest_receipt.object_id !== plan.checkpoint.manifest.object_id)
                     return null; // manifest id mismatch
@@ -5295,7 +5295,7 @@ export class GitvaultVault {
         }
     }
     /**
-     * Consume a stashed restore plan (gitvault-restore-recipe design D1-D6):
+     * Consume a stashed restore plan (vault-restore-recipe design D1-D6):
      * verify it ({@link verifyRestorePlan}) and, on success, apply it via the
      * SAME shared tail the backward walk uses ({@link applyRestoreHeads}) —
      * `null` on absence or ANY verification failure, the caller's cue to run
@@ -5319,12 +5319,12 @@ export class GitvaultVault {
         }
         return this.applyRestoreHeads(targetRepoDir, verified.heads, false, newest, writerKey, verified.checkpoint, planPacks);
     }
-    // ── compaction headroom grant (gitvault-checkpoint-cadence design D3) ──
-    /** Thin passthrough to the transport — see {@link GitvaultTransport.openCompactionGrant}. */
+    // ── compaction headroom grant (vault-checkpoint-cadence design D3) ──
+    /** Thin passthrough to the transport — see {@link VaultTransport.openCompactionGrant}. */
     async openCompactionGrant() {
         return this.transport.openCompactionGrant({ repo_id: this.repoId });
     }
-    /** Thin passthrough to the transport — see {@link GitvaultTransport.closeCompactionGrant}. Always safe best-effort; never throws by construction of the route (idempotent). */
+    /** Thin passthrough to the transport — see {@link VaultTransport.closeCompactionGrant}. Always safe best-effort; never throws by construction of the route (idempotent). */
     async closeCompactionGrant() {
         return this.transport.closeCompactionGrant({ repo_id: this.repoId });
     }
@@ -5351,7 +5351,7 @@ export function checkClaimSetEquality(claimSet, manifest, headCoversThrough) {
 /** Convenience for the deploy lane: the §6.5 capture binding. */
 export function captureBinding(captureId, applyPlanSha256, snapshotOidHmac) {
     if (!/^[0-9a-f]{32}$/.test(captureId))
-        fail("GITVAULT_BAD_ID", "capture_id must be 32 lowercase hex", "building capture binding");
+        fail("VAULT_BAD_ID", "capture_id must be 32 lowercase hex", "building capture binding");
     return { capture_id: captureId, apply_plan_sha256: applyPlanSha256, snapshot_oid_hmac: snapshotOidHmac };
 }
-//# sourceMappingURL=gitvault-publication.js.map
+//# sourceMappingURL=vault-publication.js.map