@run402/sdk 4.94.0 → 4.96.0

package/dist/namespaces/{gitvault.d.ts → repos.d.ts}

@@ -1,12 +1,12 @@
 /**
- * `r.gitvault` — the host-blind encrypted Git remote, as the SDK's programmatic
- * API (add-gitvault task 5.10).
+ * `r.repos` — the host-blind encrypted Git remote, as the SDK's programmatic
+ * API (add-vault task 5.10).
  *
  * ARCHITECTURAL LAW (client-surface spec, "All protocol logic lives in the
  * SDK"): every piece of vault protocol behaviour — crypto core, keystore,
  * creation journal, snapshot + capture, publication state machines, ref
  * transactions, verification budget, token exchange, repair — is implemented
- * ONCE here. `run402 gitvault …`, `git-remote-run402`, and the MCP tools are
+ * ONCE here. `run402 repos …`, `git-remote-run402`, and the MCP tools are
  * adapters over this namespace: argument parsing, TTY output, exit codes, and
  * local file I/O only. Anything the CLI can do is reachable programmatically
  * with identical semantics.
@@ -29,32 +29,32 @@
  * never persisted into an agent-surface result store, and never logged.
  */
 import type { Client } from "../kernel.js";
-import { GITVAULT_BYO_UNMIRRORED_REMEDY_STATEMENT, GITVAULT_DURABILITY_STATEMENT, GITVAULT_MIRROR_KEYSTORE_STILL_REQUIRED_STATEMENT, GITVAULT_MIRROR_VALIDITY_NOT_FRESHNESS_STATEMENT, GITVAULT_TERMINAL_LOSS_DOCTOR_TEXT, GITVAULT_TERMINAL_LOSS_STATEMENT, GITVAULT_UNMIRRORED_FINDING_STATEMENT } from "./gitvault.crypto.js";
+import { VAULT_BYO_UNMIRRORED_REMEDY_STATEMENT, VAULT_DURABILITY_STATEMENT, VAULT_MIRROR_KEYSTORE_STILL_REQUIRED_STATEMENT, VAULT_MIRROR_VALIDITY_NOT_FRESHNESS_STATEMENT, VAULT_TERMINAL_LOSS_DOCTOR_TEXT, VAULT_TERMINAL_LOSS_STATEMENT, VAULT_UNMIRRORED_FINDING_STATEMENT } from "./vault.crypto.js";
 import type { NextAction } from "../errors.js";
 /** The cold open's own verdicts — surfaced from `open()`; anything else leaves the handle lazy (see `open`). */
-import type { GitvaultCaptureReceipt, GitvaultHeadsListingPage, GitvaultHeadsListingRequest, GitvaultHeadTarget, GitvaultOpenReceipt, GitvaultRecipientConfirmationReceipt, GitvaultRecoveryReceipt, GitvaultRotationReason } from "./gitvault.types.js";
-import type { GitvaultCompactionGrant, GitvaultMaintenanceLease, GitvaultMaintenanceLeaseRequest, GitvaultTransport, GitvaultVaultRecord } from "../node/gitvault-publication.js";
-import type { GitvaultDeployOptions, GitvaultDeployResult } from "../node/gitvault-deploy.js";
-import type { GitvaultPublishResult, GitvaultRefMap, GitvaultReconcileEnvelopeRecipientsResult, GitvaultReconcileWriterAdmissionsResult, GitvaultVerifiedState } from "../node/gitvault-publication.js";
-import type { GitvaultCreationResult } from "../node/gitvault-creation-journal.js";
-import type { GitvaultKeystore } from "../node/gitvault-keystore.js";
-import type { GitvaultSnapshot } from "../node/gitvault-snapshot.js";
-import type { GitvaultMirrorConfig, GitvaultMirrorCredential } from "../node/gitvault-mirror-config.js";
-import type { GitvaultByoPresenceReport, GitvaultMirrorPushResult, GitvaultMirrorSyncSummary } from "../node/gitvault-mirror.js";
-import type { GitvaultRecoverResult, GitvaultVerifyReport } from "../node/gitvault-recover.js";
-import type { GitvaultMemberRecoveryBundle } from "../node/gitvault-member-bundle.js";
-import type { GitvaultDegradedReadLive, GitvaultDegradedReadOutcome, GitvaultDegradedReadSource } from "../node/gitvault-degraded-read.js";
+import type { VaultCaptureReceipt, VaultHeadsListingPage, VaultHeadsListingRequest, VaultHeadTarget, VaultOpenReceipt, VaultRecipientConfirmationReceipt, VaultRecoveryReceipt, VaultRotationReason } from "./vault.types.js";
+import type { VaultCompactionGrant, VaultMaintenanceLease, VaultMaintenanceLeaseRequest, VaultTransport, VaultRecord } from "../node/vault-publication.js";
+import type { VaultDeployOptions, VaultDeployResult } from "../node/vault-deploy.js";
+import type { VaultPublishResult, VaultRefMap, VaultReconcileEnvelopeRecipientsResult, VaultReconcileWriterAdmissionsResult, VaultVerifiedState } from "../node/vault-publication.js";
+import type { VaultCreationResult } from "../node/vault-creation-journal.js";
+import type { VaultKeystore } from "../node/vault-keystore.js";
+import type { VaultSnapshot } from "../node/vault-snapshot.js";
+import type { VaultMirrorConfig, VaultMirrorCredential } from "../node/vault-mirror-config.js";
+import type { VaultByoPresenceReport, VaultMirrorPushResult, VaultMirrorSyncSummary } from "../node/vault-mirror.js";
+import type { VaultRecoverResult, VaultVerifyReport } from "../node/vault-recover.js";
+import type { VaultMemberRecoveryBundle } from "../node/vault-member-bundle.js";
+import type { VaultDegradedReadLive, VaultDegradedReadOutcome, VaultDegradedReadSource } from "../node/vault-degraded-read.js";
 import type { RoomPresence } from "./rooms.types.js";
-/** What `r.gitvault.status()` reports. Never carries key material. */
-export interface GitvaultStatus {
+/** What `r.repos.status()` reports. Never carries key material. */
+export interface VaultStatus {
     repo_id: string | null;
     project_id: string | null;
     /** The control plane's view. `null` when no vault is allocated for the project. */
-    vault: GitvaultVaultRecord | null;
-    /** gitvault-agent-envelopes D5: what this KEY-HOLDER's session-start fulfilment did (`null` on a machine that holds no K_repo, or `reconcile: "forbidden"`). */
-    reconcile_recipients?: GitvaultSessionReconcileResult | null;
-    /** gitvault-agent-envelopes D3: what the enroll-if-absent step did for this keystore's key (`null` when it did not run). */
-    enrollment?: GitvaultEnrollmentOutcome | null;
+    vault: VaultRecord | null;
+    /** vault-agent-envelopes D5: what this KEY-HOLDER's session-start fulfilment did (`null` on a machine that holds no K_repo, or `reconcile: "forbidden"`). */
+    reconcile_recipients?: VaultSessionReconcileResult | null;
+    /** vault-agent-envelopes D3: what the enroll-if-absent step did for this keystore's key (`null` when it did not run). */
+    enrollment?: VaultEnrollmentOutcome | null;
     keystore: {
         present: boolean;
         /** The principal's Ed25519 signing fingerprint, or `null` when identity is absent. */
@@ -113,7 +113,7 @@ export interface GitvaultStatus {
      * remote pins `repo_id` in local git state the first time it resolves;
      * `resolved_from` names the `org-slug/name` it was resolved from. An
      * id-form remote never pins (it needs no pin — see
-     * `resolveGitvaultAddress`'s doc comment), so a checkout on one always
+     * `resolveVaultAddress`'s doc comment), so a checkout on one always
      * reports `null` here even once its vault is otherwise fully resolved.
      */
     pinned: {
@@ -138,17 +138,17 @@ export interface GitvaultStatus {
      * (an observation) leaves both `null`.
      */
     refs: Record<string, string> | null;
-    head_target: GitvaultHeadTarget | null;
+    head_target: VaultHeadTarget | null;
     pins: {
         highest_authenticated: string | null;
         highest_materialized: string | null;
     };
-    gitvault_policy: "required" | "grandfathered" | null;
+    vault_policy: "required" | "grandfathered" | null;
     /** Override journals on this machine that have not yet been completed. */
     pending_overrides: number;
     /**
      * Best-effort count of this vault's covering `key_envelope` recipients (the
-     * same envelope-recipients read `Gitvault.access` uses), taken inside
+     * same envelope-recipients read `Repos.access` uses), taken inside
      * `status()` when a vault is allocated. `null` when unknown — no vault, or
      * the read failed (never a new failure mode for `status`; falls back to the
      * single-principal V0-A statements below). This is what decides between
@@ -163,9 +163,9 @@ export interface GitvaultStatus {
      * `null` exactly when `covering_recipients >= 2` — see `durability_statement`
      * for what is printed in that case instead.
      */
-    terminal_loss_statement: typeof GITVAULT_TERMINAL_LOSS_STATEMENT | null;
+    terminal_loss_statement: typeof VAULT_TERMINAL_LOSS_STATEMENT | null;
     /** `null` exactly when `terminal_loss_statement` is — same condition, same reasoning. */
-    terminal_loss_detail: typeof GITVAULT_TERMINAL_LOSS_DOCTOR_TEXT | null;
+    terminal_loss_detail: typeof VAULT_TERMINAL_LOSS_DOCTOR_TEXT | null;
     /**
      * The protocol's durability sentence — printed in place of
      * `terminal_loss_statement` exactly when `covering_recipients >= 2`, since
@@ -173,7 +173,7 @@ export interface GitvaultStatus {
      * proven has a second covering recipient. `null` otherwise (including
      * "unknown" — the single-principal statements are the honest default).
      */
-    durability_statement: typeof GITVAULT_DURABILITY_STATEMENT | null;
+    durability_statement: typeof VAULT_DURABILITY_STATEMENT | null;
     warnings: {
         kind: string;
         message: string;
@@ -184,13 +184,13 @@ export interface GitvaultStatus {
     }[];
 }
 /**
- * What {@link Gitvault.scaffoldRemote} did, and why (D1). `name` is `origin`
+ * What {@link Repos.scaffoldRemote} did, and why (D1). `name` is `origin`
  * when it was free (or a caller-supplied name), `run402` when `origin` was
  * already taken by something else, or the caller's explicit `remote_name`.
  * `reason` is a human-readable sentence naming exactly what happened —
  * printed to stderr by every CLI caller, never synthesized twice.
  */
-export interface GitvaultScaffoldRemoteResult {
+export interface VaultScaffoldRemoteResult {
     /** `scaffolded`: the remote is in place (added now or already present). `skipped`: `repo_dir` lies inside
      *  another repository, which is never touched — `toplevel` names it. */
     status: "scaffolded" | "skipped";
@@ -215,24 +215,24 @@ export interface GitvaultScaffoldRemoteResult {
     excluded_in_enclosing?: boolean;
     /**
      * A `skipped` result names the way out: `create_nested_repo`, pointing at
-     * `run402 repos create --nested --project <id>` — a nested repository
+     * `run402 repos create --nested --project <project_id>` — a nested repository
      * keeps an encrypted remote for the app without touching the enclosing
      * repository. Absent on a `scaffolded` result.
      */
     next_actions?: NextAction[];
 }
-export interface GitvaultInitResult {
+export interface VaultInitResult {
     repo_id: string;
     project_id: string;
     /** Emitted once at creation — integrity data, not a secret. Print it, copy it, keep many copies. */
-    recovery_receipt: GitvaultCreationResult["recovery_receipt"];
+    recovery_receipt: VaultCreationResult["recovery_receipt"];
     genesis_sha256: string;
     /** The git remote that was added, when a working tree was scaffolded. */
-    remote: GitvaultScaffoldRemoteResult | null;
+    remote: VaultScaffoldRemoteResult | null;
     deduplicated: boolean;
-    terminal_loss_statement: typeof GITVAULT_TERMINAL_LOSS_STATEMENT;
+    terminal_loss_statement: typeof VAULT_TERMINAL_LOSS_STATEMENT;
     /**
-     * gitvault-byo-primary-bucket task 3.1/3.5 — the AUTHORITATIVE profile
+     * vault-byo-primary-bucket task 3.1/3.5 — the AUTHORITATIVE profile
      * (read back from the vault record, never assumed from what `init`'s
      * `byo` option requested). `"managed"` when `byo` was omitted, OR when it
      * was requested but this project's vault already existed as a managed
@@ -241,7 +241,7 @@ export interface GitvaultInitResult {
     storage_profile: "managed" | "byo";
     byo_destination: string | null;
 }
-export interface GitvaultCompactResult {
+export interface VaultCompactResult {
     generation: string;
     head_sha256: string;
     form: "wal" | "checkpoint";
@@ -253,11 +253,11 @@ export interface GitvaultCompactResult {
     covered_roots: number;
     /**
      * What the transient-storage preflight saw
-     * (gitvault-compaction-headroom-preflight). `null` when the preflight could
-     * not be answered — see {@link GitvaultCompactHeadroom} for why an
+     * (vault-compaction-headroom-preflight). `null` when the preflight could
+     * not be answered — see {@link VaultCompactHeadroom} for why an
      * unanswerable check never blocks maintenance.
      */
-    headroom: GitvaultCompactHeadroom | null;
+    headroom: VaultCompactHeadroom | null;
 }
 /**
  * Compaction's transient pooled-storage arithmetic.
@@ -273,7 +273,7 @@ export interface GitvaultCompactResult {
  * legibly than the platform's own storage-quota enforcement, never admit
  * something that enforcement would refuse.
  */
-export interface GitvaultCompactHeadroom {
+export interface VaultCompactHeadroom {
     /** Pooled storage the org is already using, across every project it owns. */
     pool_used_bytes: number;
     /** The org's plain, unraised pooled tier storage limit — always the tier's own figure, never the grant-raised one, so a disclosed "used of X pooled" never implies the tier itself grew. */
@@ -287,7 +287,7 @@ export interface GitvaultCompactHeadroom {
     /** `true` when the caller passed the override and a `false` `ok` was proceeded past anyway. */
     overridden: boolean;
     /**
-     * gitvault-checkpoint-cadence design D3: `pool_limit_bytes` PLUS an active
+     * vault-checkpoint-cadence design D3: `pool_limit_bytes` PLUS an active
      * compaction grant's `granted_bytes`, when one is active for this cycle —
      * the limit `ok`/`projected_transient_bytes` are actually computed
      * against. Equal to `pool_limit_bytes` (and omittable) when no grant is
@@ -301,13 +301,13 @@ export interface GitvaultCompactHeadroom {
     } | null;
 }
 /**
- * `run402 gitvault snapshot --dry-run`'s report shape
- * — {@link Gitvault.planPush}'s return type. Every sizing field is `null`,
+ * `run402 repos capture --dry-run`'s report shape
+ * — {@link Repos.planCapture}'s return type. Every sizing field is `null`,
  * and `refs`/`objects` are empty, exactly when `allocation_needed` is `true`
  * — see that method's doc comment for why sizing is genuinely UNKNOWABLE
  * (not merely unreported) before the vault's encryption key exists.
  */
-export interface GitvaultSnapshotPushPlan {
+export interface VaultSnapshotPushPlan {
     /** `true` when this project has no vault yet — a real push/snapshot would allocate one first (push-to-create). This dry run never does. */
     allocation_needed: boolean;
     base_generation: string | null;
@@ -315,8 +315,8 @@ export interface GitvaultSnapshotPushPlan {
     /** `would_admit_generation` as a plain decimal string. */
     would_admit_generation_decimal: string | null;
     form: "wal" | "checkpoint" | null;
-    refs: GitvaultRefMap;
-    head_target: GitvaultHeadTarget | null;
+    refs: VaultRefMap;
+    head_target: VaultHeadTarget | null;
     /** Every object that would be uploaded, with REAL sealed (encrypted) sizes. Empty when `allocation_needed`. */
     objects: Array<{
         object_kind: string;
@@ -328,12 +328,12 @@ export interface GitvaultSnapshotPushPlan {
     /** Sum of the plaintext pack bytes before sealing. */
     raw_bytes: string | null;
     /** The local capture this dry run computed — real, regardless of `allocation_needed`: capturing the work tree touches no network. */
-    snapshot: GitvaultSnapshot;
-    gitvault_commit: string;
-    gitvault_commit_line: string;
+    snapshot: VaultSnapshot;
+    vault_commit: string;
+    vault_commit_line: string;
 }
 /** One retention ROOT (a dropped ref tip) and whether its 90-day window has closed. */
-export interface GitvaultPruneCandidate {
+export interface VaultPruneCandidate {
     ref: string;
     oid: string;
     dropped_at_generation: string;
@@ -341,14 +341,14 @@ export interface GitvaultPruneCandidate {
     reason: string;
 }
 /** One STORED OBJECT the plan proposes deleting — what a `prune_intent`'s `delete_set` actually names. */
-export interface GitvaultPruneObjectCandidate {
+export interface VaultPruneObjectCandidate {
     object_id: string;
     object_kind: string;
     size_bytes: string;
 }
-export interface GitvaultPruneResult {
+export interface VaultPruneResult {
     /** Retention ROOTS and their windows — the retention view, unchanged. */
-    candidates: GitvaultPruneCandidate[];
+    candidates: VaultPruneCandidate[];
     eligible_count: number;
     retained_count: number;
     /**
@@ -357,7 +357,7 @@ export interface GitvaultPruneResult {
      * `retention_cutoff` ticket and its own admission times, and refuses any that
      * is not retention-eligible. A client cannot prove either fact.
      */
-    object_candidates: GitvaultPruneObjectCandidate[];
+    object_candidates: VaultPruneObjectCandidate[];
     /** Pruneable objects left out by the 10 000-per-intent cap; chunk into a later intent. */
     deferred_object_count: number;
     /** Why nothing may be pruned yet, or `null` when a submission is structurally possible. */
@@ -370,31 +370,31 @@ export interface GitvaultPruneResult {
      * and object id, so a rebuilt core is a DIFFERENT core and the receipt
      * `r402s-verify` produced would no longer bind to it.
      */
-    intent_core: import("../node/gitvault-prune.js").GitvaultPruneIntentCore | null;
+    intent_core: import("../node/vault-prune.js").VaultPruneIntentCore | null;
     intent_core_sha256: string | null;
     /** What this SDK observed while restoring the latest checkpoint — the receipt's evidence. */
-    attestation: import("../node/gitvault-publication.js").GitvaultStoredCheckpointAttestation | null;
+    attestation: import("../node/vault-publication.js").VaultStoredCheckpointAttestation | null;
     /** `true` only when an intent was accepted by the gateway. */
     submitted: boolean;
     /** The gateway's view of the submitted intent; `null` when nothing was submitted. */
-    intent: import("../node/gitvault-prune.js").GitvaultPruneIntentRecord | null;
+    intent: import("../node/vault-prune.js").VaultPruneIntentRecord | null;
     /**
      * What the control-plane-signed completion CONFIRMS. `deleted` is the only
      * result that means the bytes are gone: `present_after_attempt` is a failed
      * deletion, not a successful one.
      */
-    confirmation: import("../node/gitvault-prune.js").GitvaultPruneConfirmation | null;
+    confirmation: import("../node/vault-prune.js").VaultPruneConfirmation | null;
     note: string;
 }
 /** Options shared by every Node-only verb. */
-export interface GitvaultVaultHandleOptions {
+export interface VaultHandleOptions {
     /** The vault to act on. Resolved from `project_id` when omitted. */
     repo_id?: string;
     /** Resolve `repo_id` from the project (the cold-restart entry point). */
     project_id?: string;
     /**
-     * gitvault-agent-envelopes D5 — the session-start envelope fulfilment a
-     * KEY-HOLDING client runs on its first ordinary gitvault operation in a
+     * vault-agent-envelopes D5 — the session-start envelope fulfilment a
+     * KEY-HOLDING client runs on its first ordinary vault operation in a
      * process (read verbs included), so a pending member is covered the next
      * time ANY key-holder does anything. `"auto"` (default): run once per
      * process per vault, best-effort, reported on the handle. `"deferred"`
@@ -406,7 +406,7 @@ export interface GitvaultVaultHandleOptions {
     reconcile?: "auto" | "deferred" | "forbidden";
     /** The local git working tree. Defaults to `process.cwd()`. */
     repo_dir?: string;
-    /** Keystore root override (defaults to `~/.config/run402/gitvault`; `~/.config/run402/profiles/<wallet>/gitvault` under a named wallet). */
+    /** Keystore root override (defaults to `~/.config/run402/vault`; `~/.config/run402/profiles/<wallet>/vault` under a named wallet). */
     keystore_root?: string;
     /** Pinned service public key for control-plane signature checks (cutoff tickets). */
     service_public_key?: Uint8Array | string;
@@ -414,62 +414,62 @@ export interface GitvaultVaultHandleOptions {
     verification_budget?: number;
 }
 /** An opened vault plus the pieces the caller may want to keep using. */
-export interface GitvaultHandle {
+export interface VaultHandle {
     repo_id: string;
-    keystore: GitvaultKeystore;
-    transport: GitvaultTransport;
+    keystore: VaultKeystore;
+    transport: VaultTransport;
     /** The full protocol object — every verb below is built on it. */
-    vault: import("../node/gitvault-publication.js").GitvaultVault;
+    vault: import("../node/vault-publication.js").Vault;
     /**
-     * gitvault-agent-envelopes D4: non-null when this open restored the repo
+     * vault-agent-envelopes D4: non-null when this open restored the repo
      * file from the keystore's OWN envelope (a cold keystore joining a vault it
      * is a recipient of). Carries the honest trust tier — `platform_attested`
      * is not end-to-end authentication.
      */
-    restored: import("../node/gitvault-publication.js").GitvaultColdOpenResult | null;
+    restored: import("../node/vault-publication.js").VaultColdOpenResult | null;
     /**
-     * gitvault-agent-envelopes D5: the session-start fulfilment outcome for a
+     * vault-agent-envelopes D5: the session-start fulfilment outcome for a
      * key-holding client (`null` when this open did not run one — a restored
      * keystore has nothing to wrap yet, `reconcile: "forbidden"`, or a later
      * open in the same process). Reported beside the verb's own result, never
      * folded into it.
      */
-    reconcile_recipients: GitvaultSessionReconcileResult | null;
+    reconcile_recipients: VaultSessionReconcileResult | null;
     /**
-     * gitvault-multi-writer (task 5.7) — the session-start writer-admission
+     * vault-multi-writer (task 5.7) — the session-start writer-admission
      * reconcile's outcome. `null` exactly when `reconcile: "forbidden"` — this
      * reconcile carries no disclosure risk (it wraps nothing), so unlike
      * {@link reconcile_recipients} it is otherwise ALWAYS attempted, no
      * custody-verification gate and no once-per-process memoization: {@link
-     * import("../node/gitvault-publication.js").GitvaultVault.
+     * import("../node/vault-publication.js").Vault.
      * reconcileWriterAdmissions} is already a fast no-op (one local pin check,
      * no network call) whenever this session's own key is not an active
      * writer.
      */
-    writer_reconcile: GitvaultReconcileWriterAdmissionsPushResult | null;
-    /** gitvault-agent-envelopes D3: what the enroll-if-absent step did for this keystore's key on this open. */
-    enrollment: GitvaultEnrollmentOutcome;
+    writer_reconcile: VaultReconcileWriterAdmissionsPushResult | null;
+    /** vault-agent-envelopes D3: what the enroll-if-absent step did for this keystore's key on this open. */
+    enrollment: VaultEnrollmentOutcome;
 }
-/** The session-start reconcile's outcome (gitvault-agent-envelopes D5). */
-export interface GitvaultSessionReconcileResult {
+/** The session-start reconcile's outcome (vault-agent-envelopes D5). */
+export interface VaultSessionReconcileResult {
     attempted: boolean;
     outcome: "reconciled" | "skipped_error" | "deferred_by_local_policy" | "forbidden" | "custody_unverified";
-    result?: GitvaultReconcileEnvelopeRecipientsResult;
+    result?: VaultReconcileEnvelopeRecipientsResult;
     /** `deferred_by_local_policy` only: desired recipients this vault does not yet cover (best-effort; `null` when the read failed). */
     pending_count?: number | null;
     error?: string;
 }
-/** The enroll-if-absent step's outcome (gitvault-agent-envelopes D3). Never a rotation. */
-export interface GitvaultEnrollmentOutcome {
-    /** `already_active`: the directory holds this keystore's key (BOTH halves current — encryption active AND signing_fingerprint already matches, gitvault-multi-writer rev 47). `enrolled`: published + possession-proven in this call. `activated_pending`: an earlier unfinished publish was completed. `signing_republished` (rev 47): the encryption half was ALREADY active and needed no work; only the signing half was (re)published this call — never a rotation, the signing half is always freely republishable. `skipped_no_identity`: no local keystore identity (nothing to enroll — vault creation mints one). `skipped_no_principal`: whoami resolved no enrolling principal (e.g. a service key). `skipped_not_enrollable`: the principal's type is not custody-eligible (ci/system) — no identity is minted. `skipped_error`: whoami/publish/activate failed (older gateway, transport) — the verb still ran, but custody continuity is UNVERIFIED, so no automatic reconcile follows; `error` says why. */
+/** The enroll-if-absent step's outcome (vault-agent-envelopes D3). Never a rotation. */
+export interface VaultEnrollmentOutcome {
+    /** `already_active`: the directory holds this keystore's key (BOTH halves current — encryption active AND signing_fingerprint already matches, vault-multi-writer rev 47). `enrolled`: published + possession-proven in this call. `activated_pending`: an earlier unfinished publish was completed. `signing_republished` (rev 47): the encryption half was ALREADY active and needed no work; only the signing half was (re)published this call — never a rotation, the signing half is always freely republishable. `skipped_no_identity`: no local keystore identity (nothing to enroll — vault creation mints one). `skipped_no_principal`: whoami resolved no enrolling principal (e.g. a service key). `skipped_not_enrollable`: the principal's type is not custody-eligible (ci/system) — no identity is minted. `skipped_error`: whoami/publish/activate failed (older gateway, transport) — the verb still ran, but custody continuity is UNVERIFIED, so no automatic reconcile follows; `error` says why. */
     outcome: "already_active" | "enrolled" | "activated_pending" | "signing_republished" | "skipped_no_identity" | "skipped_no_principal" | "skipped_not_enrollable" | "skipped_error";
     ek_fingerprint: string | null;
     /**
-     * gitvault-multi-writer rev 47 (task 5.3) — the keystore's vault-WRITER
+     * vault-multi-writer rev 47 (task 5.3) — the keystore's vault-WRITER
      * signing half, published in the SAME call as the encryption half
      * whenever this keystore holds a signing seed. `null` when the identity
      * has no local signing seed (a read-only recovery identity — see
-     * `GitvaultIdentityFile.signing_seed_hex`'s own doc comment) or when the
+     * `VaultIdentityFile.signing_seed_hex`'s own doc comment) or when the
      * publish itself was never attempted (`skipped_no_identity`/
      * `skipped_no_principal`/`skipped_not_enrollable`). UNLIKE the encryption
      * half, the signing half is NEVER rotation-gated — a differing published
@@ -480,34 +480,34 @@ export interface GitvaultEnrollmentOutcome {
     signing_fingerprint: string | null;
     error?: string;
 }
-/** {@link Gitvault.push}'s best-effort envelope-recipient reconcile outcome, reported beside (never folded into) the vault result — same non-blocking contract as {@link GitvaultMirrorPushResult}. */
-export interface GitvaultReconcileEnvelopeRecipientsPushResult {
+/** {@link Repos.capture}'s best-effort envelope-recipient reconcile outcome, reported beside (never folded into) the vault result — same non-blocking contract as {@link VaultMirrorPushResult}. */
+export interface VaultReconcileEnvelopeRecipientsPushResult {
     attempted: boolean;
     outcome: "reconciled" | "skipped_error";
-    result?: GitvaultReconcileEnvelopeRecipientsResult;
+    result?: VaultReconcileEnvelopeRecipientsResult;
     error?: string;
 }
 /**
- * gitvault-multi-writer (task 5.7) — the writer-admission twin of {@link
- * GitvaultReconcileEnvelopeRecipientsPushResult}: best-effort, reported
+ * vault-multi-writer (task 5.7) — the writer-admission twin of {@link
+ * VaultReconcileEnvelopeRecipientsPushResult}: best-effort, reported
  * beside (never folded into) the vault result. ONE shape used at every
  * wiring site (push/snapshot/deploy/session-start/read) — unlike the
  * envelope reconcile's split between this push-result shape and the
- * richer {@link GitvaultSessionReconcileResult}, `"forbidden"` is included
+ * richer {@link VaultSessionReconcileResult}, `"forbidden"` is included
  * here too since this reconcile's session-start policy (task 5.7's own,
  * deliberately simpler than the envelope reconcile's custody-gated one —
- * see {@link GitvaultHandle.writer_reconcile}) honors only that one value;
+ * see {@link VaultHandle.writer_reconcile}) honors only that one value;
  * it is simply unreachable at the push/snapshot/deploy sites, which never
  * check `options.reconcile` for this hook.
  */
-export interface GitvaultReconcileWriterAdmissionsPushResult {
+export interface VaultReconcileWriterAdmissionsPushResult {
     attempted: boolean;
     outcome: "reconciled" | "skipped_error" | "forbidden";
-    result?: GitvaultReconcileWriterAdmissionsResult;
+    result?: VaultReconcileWriterAdmissionsResult;
     error?: string;
 }
-/** {@link Gitvault.handoff}'s result. `handoff_key` (the assembled `kgh1_…`) is returned exactly ONCE. */
-export interface GitvaultHandoffMintResult {
+/** {@link Repos.handoff}'s result. `handoff_key` (the assembled `kgh1_…`) is returned exactly ONCE. */
+export interface VaultHandoffMintResult {
     handoff_key: string;
     handoff_id: string;
     kind: "handoff";
@@ -530,14 +530,14 @@ export interface GitvaultHandoffMintResult {
         ignored_not_transferred_count: number;
     };
     /** The full local capture result, for a caller that wants more than the summarized `capture` block. */
-    snapshot: import("../node/gitvault-snapshot.js").GitvaultHandoffSnapshot;
+    snapshot: import("../node/vault-snapshot.js").VaultHandoffSnapshot;
     warnings: {
         code: string;
         message: string;
     }[];
     next_actions: NextAction[];
 }
-export interface GitvaultHandoffListEntry {
+export interface VaultHandoffListEntry {
     handoff_id: string;
     kind: string;
     state: "issued" | "redeemed" | "expired" | "revoked";
@@ -546,16 +546,16 @@ export interface GitvaultHandoffListEntry {
     expires_at: string;
     redeemed_by?: string | null;
 }
-export interface GitvaultHandoffListResult {
-    handoffs: GitvaultHandoffListEntry[];
+export interface VaultHandoffListResult {
+    handoffs: VaultHandoffListEntry[];
 }
-/** {@link Gitvault.resume}'s result. */
-export interface GitvaultHandoffResumeResult {
+/** {@link Repos.resume}'s result. */
+export interface VaultHandoffResumeResult {
     handoff_id: string;
     kind: "handoff";
     deduplicated: boolean;
     /** The Handoff Note, parsed — `null` when the commit message could not be read/parsed (still restored either way). */
-    note: import("../node/gitvault-handoff.js").KygitHandoffNote | null;
+    note: import("../node/vault-handoff.js").KygitHandoffNote | null;
     /** The note's raw commit-message text, for a caller that wants Markdown rendering over the parsed shape. */
     note_raw: string | null;
     restored: {
@@ -571,20 +571,20 @@ export interface GitvaultHandoffResumeResult {
     };
     members: unknown[];
     expires_at: string;
-    /** gitvault-multi-writer rev 47 (task 5.6, design D5) — this checkout's own writer activation. `outcome: "active"` covers BOTH a fresh submission this call made and the idempotent-skip case (a prior attempt's activation already landed) — the writer IS active either way. */
+    /** vault-multi-writer rev 47 (task 5.6, design D5) — this checkout's own writer activation. `outcome: "active"` covers BOTH a fresh submission this call made and the idempotent-skip case (a prior attempt's activation already landed) — the writer IS active either way. */
     writer_activation: {
         outcome: "active";
         writer_key_id: string;
         generation: string;
     };
-    reconcile_recipients: GitvaultReconcileEnvelopeRecipientsPushResult;
+    reconcile_recipients: VaultReconcileEnvelopeRecipientsPushResult;
     next_actions: NextAction[];
 }
 /**
  * The gateway names the vault by its three ids on the wire — `repo_id`,
  * `org_id`, `project_id` (docs/style.md's API-boundary vocabulary) — on
- * BOTH the handoff mint (`POST /gitvault/v1/vaults/:vault_id/handoffs`) and
- * claim (`POST /gitvault/v1/handoffs/:handoff_id/redeem`) responses. The SDK
+ * BOTH the handoff mint (`POST /vaults/v1/:vault_id/handoffs`) and
+ * claim (`POST /vaults/v1/handoffs/:handoff_id/redeem`) responses. The SDK
  * groups them under `vault` with the `organization_id` spelling every other
  * SDK result uses. Neither response carries a slug-form address, so
  * `address` is `null` unless the caller already knows one (a slug-form
@@ -594,13 +594,13 @@ export declare function handoffVaultFromWire(wire: {
     repo_id: string;
     org_id: string;
     project_id: string;
-}, address?: string | null): GitvaultHandoffMintResult["vault"];
+}, address?: string | null): VaultHandoffMintResult["vault"];
 /** The redeem response's `membership` block (`org_id` on the wire) in the SDK's `organization_id` spelling. Pure; exported for tests. */
 export declare function handoffMembershipFromWire(wire: {
     org_id: string;
     role: string;
     status: string;
-}): GitvaultHandoffResumeResult["membership"];
+}): VaultHandoffResumeResult["membership"];
 /**
  * An invite mints at `developer` unless `--role` narrows it or the minter's
  * own role is narrower — the ONE descriptor difference from a handoff, which
@@ -612,12 +612,12 @@ export declare function handoffMembershipFromWire(wire: {
  */
 export declare const INVITE_DEFAULT_ROLE = "developer";
 /** A room's `(org_id, room_key)` pair, as it rides the invite mint/redeem responses. */
-export interface GitvaultInviteRoom {
+export interface VaultInviteRoom {
     organization_id: string;
     room_key: string;
 }
-/** Best-effort report of whether {@link Gitvault.invite}'s room message was posted — a failure here (e.g. the daily quota) never voids the mint (design D4). */
-export interface GitvaultInviteRoomMessageResult {
+/** Best-effort report of whether {@link Repos.invite}'s room message was posted — a failure here (e.g. the daily quota) never voids the mint (design D4). */
+export interface VaultInviteRoomMessageResult {
     posted: boolean;
     message_id?: string;
     /** The posted message's room cursor — a CLI advances the inviter's stored cursor past it, so the inviter's own `messages wait` is woken by the joiner's arrival, never by its own message. */
@@ -625,14 +625,14 @@ export interface GitvaultInviteRoomMessageResult {
     reason?: string;
 }
 /** Best-effort report of whether the inviter's own presence was registered before minting (design D4) — the mint still proceeds without one. */
-export interface GitvaultInvitePresenceResult {
+export interface VaultInvitePresenceResult {
     registered: boolean;
     presence_id?: string;
     name?: string;
     error?: string;
 }
-/** {@link Gitvault.invite}'s result. `invite_key` (the assembled `kgi1_…`) is returned exactly ONCE. */
-export interface GitvaultInviteMintResult {
+/** {@link Repos.invite}'s result. `invite_key` (the assembled `kgi1_…`) is returned exactly ONCE. */
+export interface VaultInviteMintResult {
     invite_key: string;
     invite_id: string;
     kind: "invite";
@@ -644,7 +644,7 @@ export interface GitvaultInviteMintResult {
         organization_id: string;
         project_id: string;
     };
-    room: GitvaultInviteRoom;
+    room: VaultInviteRoom;
     checkpoint: {
         generation: string;
         snapshot_oid_hmac: string;
@@ -656,16 +656,16 @@ export interface GitvaultInviteMintResult {
         ignored_not_transferred_count: number;
     };
     /** The full local capture result, for a caller that wants more than the summarized `capture` block. */
-    snapshot: import("../node/gitvault-snapshot.js").GitvaultHandoffSnapshot;
-    inviter_presence: GitvaultInvitePresenceResult;
-    room_message: GitvaultInviteRoomMessageResult;
+    snapshot: import("../node/vault-snapshot.js").VaultHandoffSnapshot;
+    inviter_presence: VaultInvitePresenceResult;
+    room_message: VaultInviteRoomMessageResult;
     warnings: {
         code: string;
         message: string;
     }[];
     next_actions: NextAction[];
 }
-export interface GitvaultInviteListEntry {
+export interface VaultInviteListEntry {
     invite_id: string;
     kind: string;
     state: "issued" | "redeemed" | "expired" | "revoked";
@@ -675,11 +675,11 @@ export interface GitvaultInviteListEntry {
     expires_at: string;
     redeemed_by?: string | null;
 }
-export interface GitvaultInviteListResult {
-    invites: GitvaultInviteListEntry[];
+export interface VaultInviteListResult {
+    invites: VaultInviteListEntry[];
 }
-/** The inviter's presence, resolved live at redeem time (design gitvault-invite's own claim requirement) — `null` when the inviter never registered one. */
-export interface GitvaultInviteInviter {
+/** The inviter's presence, resolved live at redeem time (design vault-invite's own claim requirement) — `null` when the inviter never registered one. */
+export interface VaultInviteInviter {
     presence_id: string;
     name: string;
     program: string | null;
@@ -687,13 +687,13 @@ export interface GitvaultInviteInviter {
     state: string;
     last_active: string;
 }
-/** {@link Gitvault.join}'s result. */
-export interface GitvaultInviteJoinResult {
+/** {@link Repos.join}'s result. */
+export interface VaultInviteJoinResult {
     invite_id: string;
     kind: "invite";
     deduplicated: boolean;
     /** The Invite Note, parsed — `null` when the commit message could not be read/parsed (still restored either way). */
-    note: import("../node/gitvault-handoff.js").KygitInviteNote | null;
+    note: import("../node/vault-handoff.js").KygitInviteNote | null;
     /** The note's raw commit-message text, for a caller that wants Markdown rendering over the parsed shape. */
     note_raw: string | null;
     restored: {
@@ -708,8 +708,8 @@ export interface GitvaultInviteJoinResult {
         status: string;
     };
     members: unknown[];
-    room: GitvaultInviteRoom;
-    inviter: GitvaultInviteInviter | null;
+    room: VaultInviteRoom;
+    inviter: VaultInviteInviter | null;
     /** This session's OWN presence in the room (what the arrival fact was posted as), or `null` when registration failed. A CLI persists it into the joined checkout so the first `messages wait` there speaks as the same session. */
     presence: {
         presence_id: string;
@@ -722,9 +722,9 @@ export interface GitvaultInviteJoinResult {
     recent_messages: unknown[];
     expires_at: string;
     /**
-     * gitvault-multi-writer rev 47 (kygit-invite design D5/D9) — this
+     * vault-multi-writer rev 47 (kygit-invite design D5/D9) — this
      * checkout's own writer activation, driven through the SAME shared
-     * `add_writer_key` door {@link Gitvault.resume} uses, BEFORE `join()`
+     * `add_writer_key` door {@link Repos.resume} uses, BEFORE `join()`
      * returns, so the joiner's first `git push` is an ordinary push.
      * `outcome: "active"` covers both a fresh submission and the
      * idempotent-skip case. `outcome: "pending"` is D9's not-stranded path: a
@@ -741,12 +741,12 @@ export interface GitvaultInviteJoinResult {
         writer_key_id: string;
         reason: string;
     };
-    reconcile_recipients: GitvaultReconcileEnvelopeRecipientsPushResult;
+    reconcile_recipients: VaultReconcileEnvelopeRecipientsPushResult;
     next_actions: NextAction[];
 }
-/** What {@link Gitvault.openOrCreate} did. `created` is `null` exactly when `found` is `true`. */
+/** What {@link Repos.openOrCreate} did. `created` is `null` exactly when `found` is `true`. */
 /** `run402 repos mirror` (no-arg, a READ) and `repos view`'s mirror summary both compose this — what this machine and the mirror each believe (both honesty statements ride every response). */
-export interface GitvaultMirrorStatus {
+export interface VaultMirrorStatus {
     repo_id: string;
     configured: boolean;
     /** `s3://bucket/prefix` or a directory path — never a credential. */
@@ -760,31 +760,31 @@ export interface GitvaultMirrorStatus {
     is_current: boolean | null;
     /** Present exactly when `is_current === false`. */
     closing_command: string | null;
-    /** gitvault-mirror-default: when a mirror write/sync last completed with zero failures (local config fact — never transmitted). `null` when unconfigured or never succeeded. */
+    /** vault-mirror-default: when a mirror write/sync last completed with zero failures (local config fact — never transmitted). `null` when unconfigured or never succeeded. */
     last_success_at: string | null;
-    /** gitvault-mirror-default: the standing `vault_unmirrored` finding — informational, never blocking; `null` once a mirror write or sync has succeeded (see {@link gitvaultUnmirroredFinding}). */
-    finding: GitvaultUnmirroredFinding | null;
-    validity_not_freshness: typeof GITVAULT_MIRROR_VALIDITY_NOT_FRESHNESS_STATEMENT;
-    keystore_still_required: typeof GITVAULT_MIRROR_KEYSTORE_STILL_REQUIRED_STATEMENT;
+    /** vault-mirror-default: the standing `vault_unmirrored` finding — informational, never blocking; `null` once a mirror write or sync has succeeded (see {@link vaultUnmirroredFinding}). */
+    finding: VaultUnmirroredFinding | null;
+    validity_not_freshness: typeof VAULT_MIRROR_VALIDITY_NOT_FRESHNESS_STATEMENT;
+    keystore_still_required: typeof VAULT_MIRROR_KEYSTORE_STILL_REQUIRED_STATEMENT;
 }
 /**
- * gitvault-mirror-default — the named standing finding for a vault with no
- * customer-held mirror copy yet. gitvault-byo-primary-bucket task 3.5
+ * vault-mirror-default — the named standing finding for a vault with no
+ * customer-held mirror copy yet. vault-byo-primary-bucket task 3.5
  * widens `message` to the BYO remedy wording ({@link
- * GITVAULT_BYO_UNMIRRORED_REMEDY_STATEMENT}) for a BYO vault — it applies
+ * VAULT_BYO_UNMIRRORED_REMEDY_STATEMENT}) for a BYO vault — it applies
  * there too (D7): a single-bucket BYO vault has exactly as few copies as an
  * unmirrored managed one, and the remedy names a SECOND customer-held
  * location the same way.
  */
-export interface GitvaultUnmirroredFinding {
+export interface VaultUnmirroredFinding {
     kind: "vault_unmirrored";
-    message: typeof GITVAULT_UNMIRRORED_FINDING_STATEMENT | typeof GITVAULT_BYO_UNMIRRORED_REMEDY_STATEMENT;
+    message: typeof VAULT_UNMIRRORED_FINDING_STATEMENT | typeof VAULT_BYO_UNMIRRORED_REMEDY_STATEMENT;
     /** The one command that moves toward clearing it: configure when unconfigured, backfill when configured-but-never-succeeded. */
     setup_command: string;
 }
 /**
- * gitvault-byo-primary-bucket task 3.3 — the number of `{key, object_kind}`
- * entries `GITVAULT_BYO_OBJECT_MISSING`'s `details.missing` lists before
+ * vault-byo-primary-bucket task 3.3 — the number of `{key, object_kind}`
+ * entries `VAULT_BYO_OBJECT_MISSING`'s `details.missing` lists before
  * truncating (`details.missing_count` always carries the true total, and
  * `details.missing_truncated` says whether the list above was cut). A
  * chain-referenced object list can be arbitrarily large; an error envelope
@@ -792,22 +792,22 @@ export interface GitvaultUnmirroredFinding {
  * `sample_keys`-class cap (asset-sync's plan response, `PLATFORM_INCIDENT_
  * FANOUT_CAP`) rather than inventing a new number.
  */
-export declare const GITVAULT_BYO_OBJECT_MISSING_LIST_CAP = 50;
+export declare const VAULT_BYO_OBJECT_MISSING_LIST_CAP = 50;
 /**
- * gitvault-byo-primary-bucket task 3.3 (design D6) — `repos fsck`'s wiring of
- * the shipped {@link import("../node/gitvault-mirror.js").verifyByoObjectsPresent}
- * read-half primitive. Present on {@link GitvaultFsckResult.byo_presence}
+ * vault-byo-primary-bucket task 3.3 (design D6) — `repos fsck`'s wiring of
+ * the shipped {@link import("../node/vault-mirror.js").verifyByoObjectsPresent}
+ * read-half primitive. Present on {@link VaultFsckResult.byo_presence}
  * ONLY for a `storage_profile: "byo"` vault — `undefined` (the key absent
  * from JSON entirely) for a managed vault, so a managed vault's `fsck`
  * output is byte-identical to before this task.
  *
  * `verified: true` NEVER coexists with a missing object: a nonzero absence
- * throws `GITVAULT_BYO_OBJECT_MISSING` instead of returning here (see
- * {@link Gitvault.fsck}'s own doc comment) — this shape only ever reports
+ * throws `VAULT_BYO_OBJECT_MISSING` instead of returning here (see
+ * {@link Repos.fsck}'s own doc comment) — this shape only ever reports
  * the two honest non-failure outcomes, "checked, all present" and "could
  * not check".
  */
-export interface GitvaultFsckByoPresence {
+export interface VaultFsckByoPresence {
     /**
      * `true` iff this call actually HEAD-checked the destination (local BYO
      * write credentials were configured on this machine). `false` means "not
@@ -828,7 +828,7 @@ export interface GitvaultFsckByoPresence {
  * implicit — the external review's clause-5 requirement for any verb that
  * may advance local trust state.
  */
-export interface GitvaultFsckResult {
+export interface VaultFsckResult {
     repo_id: string;
     /** `false` under `--no-write` (`write: false`) — nothing local was persisted, regardless of what was computed. */
     write: boolean;
@@ -849,12 +849,12 @@ export interface GitvaultFsckResult {
      * falls short of it when an admitted `rotate_epoch` transition's own
      * envelope could not be opened by this keystore (`epoch_decrypt_failure`
      * names exactly which epoch/rotation and why — never a bare, undifferentiated
-     * `GITVAULT_AEAD_AUTH_FAILURE`). `refs`/`head_target`/`pin_after.highest_materialized`
+     * `VAULT_AEAD_AUTH_FAILURE`). `refs`/`head_target`/`pin_after.highest_materialized`
      * below all reflect THIS generation, not the chain-verified one, when they differ.
      */
     decryptable_to_generation: string;
     /** Non-null iff `decryptable_to_generation` fell short of `chain_verified_to_generation` — the named epoch boundary (Request 1). */
-    epoch_decrypt_failure: import("../node/gitvault-publication.js").GitvaultEpochDecryptFailure | null;
+    epoch_decrypt_failure: import("../node/vault-publication.js").VaultEpochDecryptFailure | null;
     /** `true` only when `write` was true AND a pin actually moved. */
     local_state_changed: boolean;
     pin_before: {
@@ -866,10 +866,10 @@ export interface GitvaultFsckResult {
         highest_materialized: string | null;
     };
     /** The real, computed ref map, AS OF `decryptable_to_generation` — present even under `--no-write` (computing is not the same as persisting). */
-    refs: GitvaultRefMap;
-    head_target: GitvaultHeadTarget | null;
+    refs: VaultRefMap;
+    head_target: VaultHeadTarget | null;
     /** Present only when `--mirror` was requested. Proves validity, never freshness — see its own honesty statements. */
-    mirror: GitvaultVerifyReport | null;
+    mirror: VaultVerifyReport | null;
     /**
      * clone-installs-retained-refs (D2, task 1.3): the healing path for a
      * pre-change clone (or a checkout whose original write degraded per D3) —
@@ -878,7 +878,7 @@ export interface GitvaultFsckResult {
      * `repo_dir` is not itself a git repository — an ordinary, silent no-op,
      * never a warning).
      */
-    retained_refs: import("../node/gitvault-publication.js").GitvaultRetainedRefsReconcileResult | null;
+    retained_refs: import("../node/vault-publication.js").VaultRetainedRefsReconcileResult | null;
     /**
      * D210 (rev 44) — best-effort submission of THIS call's OWN
      * `chain_verified_to_generation`/`decryptable_to_generation` as
@@ -893,20 +893,20 @@ export interface GitvaultFsckResult {
      * `OPEN_PROOF_MISMATCH`) is recorded in `error` and nothing else; a
      * `recipient_open_receipt` is EVIDENCE, never authorization (§4.14).
      */
-    open_proof: GitvaultOpenProofOutcome;
+    open_proof: VaultOpenProofOutcome;
     /**
-     * gitvault-byo-primary-bucket task 3.3 — see {@link GitvaultFsckByoPresence}.
+     * vault-byo-primary-bucket task 3.3 — see {@link VaultFsckByoPresence}.
      * Absent entirely (not `null`) for a `storage_profile: "managed"` vault, so
      * `JSON.stringify` drops the key and a managed vault's `fsck` output stays
      * byte-identical to before this task existed. A `verified: true` result
      * with objects missing is never returned here — see the interface's own
-     * doc comment for why that case throws `GITVAULT_BYO_OBJECT_MISSING`
+     * doc comment for why that case throws `VAULT_BYO_OBJECT_MISSING`
      * instead.
      */
-    byo_presence?: GitvaultFsckByoPresence;
+    byo_presence?: VaultFsckByoPresence;
 }
-/** {@link GitvaultFsckResult.open_proof} — the outcome of `fsck`'s best-effort D210 proof-of-open submission. */
-export interface GitvaultOpenProofOutcome {
+/** {@link VaultFsckResult.open_proof} — the outcome of `fsck`'s best-effort D210 proof-of-open submission. */
+export interface VaultOpenProofOutcome {
     /** `false` iff this call decided LOCALLY there was nothing to submit (write:false, or no local encryption identity) — no network call was made. */
     attempted: boolean;
     /** `true` iff the gateway accepted the submission (200 or 201) — `receipt`/`deduplicated` are populated. */
@@ -914,7 +914,7 @@ export interface GitvaultOpenProofOutcome {
     /** `true` — the gateway returned the tuple's EXISTING receipt (200, an idempotent replay). `false` — a fresh receipt was minted (201). `null` when `submitted` is `false`. */
     deduplicated: boolean | null;
     /** The `recipient_open_receipt` the gateway returned, present iff `submitted`. */
-    receipt: GitvaultOpenReceipt | null;
+    receipt: VaultOpenReceipt | null;
     /** Present iff `attempted` and NOT `submitted` — why the gateway (or principal resolution before it) refused. */
     error: {
         code: string;
@@ -923,11 +923,11 @@ export interface GitvaultOpenProofOutcome {
 }
 /**
  * D210 (rev 44) — the decision function behind `fsck`'s best-effort
- * proof-of-open submission, factored out of {@link Gitvault}'s private
+ * proof-of-open submission, factored out of {@link Repos}'s private
  * `#submitFsckOpenProof` so it is directly unit-testable with injected
  * (fake) `resolvePrincipalId`/`submit` dependencies, independent of a real
  * HTTP-backed vault. `fsck()` itself supplies the REAL dependencies (`GET
- * /agent/v1/whoami`, {@link Gitvault.submitProofOfOpen}) — this function
+ * /agent/v1/whoami`, {@link Repos.submitProofOfOpen}) — this function
  * contains no HTTP/transport code of its own.
  *
  * Gating (all LOCAL, no network call made when either holds):
@@ -962,13 +962,13 @@ export declare function computeOpenProofOutcome(input: {
         decryptable_to_generation: string;
         reader_entrypoint: string;
     }) => Promise<{
-        receipt: GitvaultOpenReceipt;
+        receipt: VaultOpenReceipt;
         deduplicated: boolean;
     }>;
-}): Promise<GitvaultOpenProofOutcome>;
+}): Promise<VaultOpenProofOutcome>;
 /**
- * gitvault-byo-primary-bucket task 3.3 (design D6) — the decision function
- * behind `fsck`'s BYO presence check, factored out of {@link Gitvault}'s
+ * vault-byo-primary-bucket task 3.3 (design D6) — the decision function
+ * behind `fsck`'s BYO presence check, factored out of {@link Repos}'s
  * private `#checkByoPresence` the same way {@link computeOpenProofOutcome}
  * is factored out of `#submitFsckOpenProof`, so it is directly unit-testable
  * with an injected (fake) `hasLocalConfig`/`verifyPresence`, independent of
@@ -988,15 +988,15 @@ export declare function computeOpenProofOutcome(input: {
  * NO local credentials configured (`hasLocalConfig()` returns `false`) is
  * reported, never thrown — a BYO vault this machine cannot reach is an
  * honest "not checked", not a failure that should break `fsck` for a
- * credential-less returning agent (see {@link GitvaultFsckByoPresence}'s
+ * credential-less returning agent (see {@link VaultFsckByoPresence}'s
  * own doc comment). A confirmed absence is the opposite: it THROWS
- * `GITVAULT_BYO_OBJECT_MISSING` — the same severity class as {@link
- * Gitvault.mirrorVerify}'s own `GITVAULT_MIRROR_NOT_CONFIGURED` throw when
+ * `VAULT_BYO_OBJECT_MISSING` — the same severity class as {@link
+ * Repos.mirrorVerify}'s own `VAULT_MIRROR_NOT_CONFIGURED` throw when
  * `--mirror` is requested against an unconfigured vault — this is exactly
  * the honesty D6 names: "we can tell the customer what SHOULD exist and
  * does not", stated as a real refusal rather than a silently-embedded
  * finding. The listed entries are capped at
- * {@link GITVAULT_BYO_OBJECT_MISSING_LIST_CAP} (a chain-referenced object
+ * {@link VAULT_BYO_OBJECT_MISSING_LIST_CAP} (a chain-referenced object
  * list can be arbitrarily large and this is an error envelope, not a
  * report); `missing_count` always carries the true total regardless of how
  * many are listed.
@@ -1013,8 +1013,8 @@ export declare function computeByoPresenceOutcome(input: {
         byo_destination?: string | null;
     } | null;
     hasLocalConfig: () => boolean;
-    verifyPresence: () => Promise<GitvaultByoPresenceReport>;
-}): Promise<GitvaultFsckByoPresence | undefined>;
+    verifyPresence: () => Promise<VaultByoPresenceReport>;
+}): Promise<VaultFsckByoPresence | undefined>;
 /**
  * `repos access`'s result — a READ over whatever the live gateway surface
  * exposes today. The gateway's `envelope-recipients` read reports
@@ -1029,13 +1029,13 @@ export declare function computeByoPresenceOutcome(input: {
  *
  * ONE gap remains genuine and gateway-independent: `history_scope` (which
  * epochs each recipient can read) has no substrate to report, because
- * gitvault protocol v0 pins a single fixed epoch for a vault's entire
+ * vault protocol v0 pins a single fixed epoch for a vault's entire
  * lifetime — there is no per-epoch scope to have. `stale_access` below is
  * the closest observable proxy for the same underlying limitation: a
  * `pending_removal` recipient whose fingerprint is STILL covered still
  * decrypts every commit (past AND future) under that one epoch, because
  * epoch rotation — the mechanism that would actually revoke them — is
- * mid-fold in `gitvault-human-envelopes` under adversarial protocol review.
+ * mid-fold in `vault-human-envelopes` under adversarial protocol review.
  *
  * `access` reports what the read surface HAS: the org's directory of
  * encryption-key-holding members, which of the vault's current
@@ -1044,7 +1044,7 @@ export declare function computeByoPresenceOutcome(input: {
  * (Node-only, best-effort) this machine's own local TOFU pin for each
  * principal, when it has ever wrapped one.
  */
-export interface GitvaultAccessRecipient {
+export interface VaultAccessRecipient {
     principal_id: string;
     display_name: string | null;
     /** This recipient's fingerprint per the org directory. */
@@ -1068,20 +1068,20 @@ export interface GitvaultAccessRecipient {
         matches_directory: boolean;
     } | null;
 }
-/** A principal whose membership was removed (desired state `pending_removal`) but who STILL holds a covering `key_envelope` on this vault — real, continuing access that removal did not revoke, because gitvault v0 has no epoch-rotation mechanism yet. See {@link GitvaultAccessResult}'s doc comment. */
-export interface GitvaultStaleAccessEntry {
+/** A principal whose membership was removed (desired state `pending_removal`) but who STILL holds a covering `key_envelope` on this vault — real, continuing access that removal did not revoke, because vault v0 has no epoch-rotation mechanism yet. See {@link VaultAccessResult}'s doc comment. */
+export interface VaultStaleAccessEntry {
     principal_id: string;
     display_name: string | null;
     fingerprint: string;
 }
-export interface GitvaultAccessResult {
+export interface VaultAccessResult {
     repo_id: string;
     org_id: string | null;
-    /** gitvault-agent-envelopes D5: this KEY-HOLDER's session-start fulfilment outcome (`null` when this machine holds no K_repo for the vault, or `reconcile: "forbidden"`). */
-    reconcile_recipients?: GitvaultSessionReconcileResult | null;
-    /** gitvault-agent-envelopes D3: the enroll-if-absent step's outcome (`null` when it did not run). */
-    enrollment?: GitvaultEnrollmentOutcome | null;
-    recipients: GitvaultAccessRecipient[];
+    /** vault-agent-envelopes D5: this KEY-HOLDER's session-start fulfilment outcome (`null` when this machine holds no K_repo for the vault, or `reconcile: "forbidden"`). */
+    reconcile_recipients?: VaultSessionReconcileResult | null;
+    /** vault-agent-envelopes D3: the enroll-if-absent step's outcome (`null` when it did not run). */
+    enrollment?: VaultEnrollmentOutcome | null;
+    recipients: VaultAccessRecipient[];
     /** Vault-covering fingerprints (from the server) that match neither a directory entry nor a desired-state row — genuinely orphaned, revoked outside this org's membership model, or external. Excludes fingerprints already explained by `stale_access` AND by `this_keystore`. */
     unmatched_covered_fingerprints: string[];
     /**
@@ -1095,9 +1095,9 @@ export interface GitvaultAccessResult {
      */
     this_keystore: {
         fingerprint: string;
-        /** `true` iff the directory holds this keystore's key as ACTIVE (gitvault-agent-envelopes: agents enroll too). */
+        /** `true` iff the directory holds this keystore's key as ACTIVE (vault-agent-envelopes: agents enroll too). */
         enrolled: boolean;
-        /** `absent` = no published key (the next gitvault operation enrolls); `pending` = published, possession unproven; `rotation_required` = the principal's published key is a DIFFERENT key; `unknown` = whoami unavailable. */
+        /** `absent` = no published key (the next vault operation enrolls); `pending` = published, possession unproven; `rotation_required` = the principal's published key is a DIFFERENT key; `unknown` = whoami unavailable. */
         publish_state: "active" | "pending" | "absent" | "rotation_required" | "unknown";
         covered_on_this_vault: boolean;
         /** @deprecated alias of `covered_on_this_vault`. */
@@ -1107,8 +1107,8 @@ export interface GitvaultAccessResult {
             why: string;
         }>;
     } | null;
-    /** Removed members who still decrypt this vault — see {@link GitvaultStaleAccessEntry}. Always `[]` when `envelope_state_available` is `false` (no desired-state substrate to compute it from). */
-    stale_access: GitvaultStaleAccessEntry[];
+    /** Removed members who still decrypt this vault — see {@link VaultStaleAccessEntry}. Always `[]` when `envelope_state_available` is `false` (no desired-state substrate to compute it from). */
+    stale_access: VaultStaleAccessEntry[];
     /** `true` when the gateway reported desired-recipient state (`desired[]`) for this read, making `recipients[].envelope_state` and `stale_access` real rather than absent. `false` only against an older gateway. */
     envelope_state_available: boolean;
     /** Always `false` — see this type's own doc comment for why this is a protocol-level absence, not a missing gateway feature. */
@@ -1123,7 +1123,7 @@ export interface GitvaultAccessResult {
 }
 /**
  * `repos list`'s bulk read —
- * `GET /gitvault/v1/vaults?org_id=<uuid>`.
+ * `GET /vaults/v1?org_id=<uuid>`.
  * FROZEN response shape, agreed with the gateway
  * team ahead of the route landing; the route may still 404 on a gateway
  * that has not shipped it yet, and callers should fall back to the
@@ -1131,41 +1131,41 @@ export interface GitvaultAccessResult {
  * `cli/lib/repos.mjs`'s `list()` for that fallback, kept only until every
  * deployed gateway answers this route.
  */
-export interface GitvaultOrgVaultSummary {
+export interface VaultOrgVaultSummary {
     repo_id: string;
     project_id: string;
     project_name: string | null;
     repo_name: string | null;
     org_slug: string | null;
-    gitvault_policy: "required" | "grandfathered" | null;
+    vault_policy: "required" | "grandfathered" | null;
     newest_generation: string | null;
     source_bytes: string;
     genesis_admitted_at: string | null;
     created_at: string;
-    /** gitvault-byo-primary-bucket task 3.5 — absent-or-`"managed"` is byte-identical to today. */
+    /** vault-byo-primary-bucket task 3.5 — absent-or-`"managed"` is byte-identical to today. */
     storage_profile?: "managed" | "byo";
 }
-export interface GitvaultOrgVaultsListing {
-    vaults: GitvaultOrgVaultSummary[];
+export interface VaultOrgVaultsListing {
+    vaults: VaultOrgVaultSummary[];
     /** Keyset pagination (agent-response-design): opaque, store-and-echo. */
     has_more?: boolean;
     next_cursor?: string | null;
 }
-export interface GitvaultOpenOrCreateResult {
-    handle: GitvaultHandle;
+export interface VaultOpenOrCreateResult {
+    handle: VaultHandle;
     /** `true` when the vault already existed — nothing was allocated by this call. */
     found: boolean;
     created: {
-        /** Mirrors `GitvaultInitResult.deduplicated`: an existing local creation journal was resumed to completion rather than started fresh — nothing was re-minted. */
+        /** Mirrors `VaultInitResult.deduplicated`: an existing local creation journal was resumed to completion rather than started fresh — nothing was re-minted. */
         deduplicated: boolean;
         /** Emitted once at creation — integrity data, not a secret. Print it, copy it, keep many copies. Persisted into the keystore regardless. */
-        recovery_receipt: GitvaultCreationResult["recovery_receipt"];
+        recovery_receipt: VaultCreationResult["recovery_receipt"];
         genesis_sha256: string;
     } | null;
-    terminal_loss_statement: typeof GITVAULT_TERMINAL_LOSS_STATEMENT;
+    terminal_loss_statement: typeof VAULT_TERMINAL_LOSS_STATEMENT;
 }
 /**
- * {@link Gitvault.deploy}'s post-push glue: attach the best-effort
+ * {@link Repos.deploy}'s post-push glue: attach the best-effort
  * mirror/reconcile hooks to a deploy result, gated on whether this deploy
  * actually landed a new generation in the vault. Extracted as a standalone
  * function (rather than inlined in `deploy()`) purely so the gating can be
@@ -1182,49 +1182,49 @@ export interface GitvaultOpenOrCreateResult {
  * `reconcile_recipients` are OMITTED rather than a faked `skipped_*` value —
  * there is nothing this deploy did that either hook could report on.
  */
-export declare function attachGitvaultDeployHooks(result: GitvaultDeployResult, mirror: () => Promise<GitvaultMirrorPushResult>, reconcile: () => Promise<GitvaultReconcileEnvelopeRecipientsPushResult>): Promise<GitvaultDeployResult & {
-    mirror_push?: GitvaultMirrorPushResult;
-    reconcile_recipients?: GitvaultReconcileEnvelopeRecipientsPushResult;
+export declare function attachVaultDeployHooks(result: VaultDeployResult, mirror: () => Promise<VaultMirrorPushResult>, reconcile: () => Promise<VaultReconcileEnvelopeRecipientsPushResult>): Promise<VaultDeployResult & {
+    mirror_push?: VaultMirrorPushResult;
+    reconcile_recipients?: VaultReconcileEnvelopeRecipientsPushResult;
 }>;
-export declare class Gitvault {
+export declare class Repos {
     #private;
     constructor(client: Client);
     /** The vault record — policy, allocation generation, storage + maintenance state. */
-    get(repoId: string): Promise<GitvaultVaultRecord>;
+    get(repoId: string): Promise<VaultRecord>;
     /**
      * Resolve a project's vault with no local state. This is the cold-restart
      * entry point: an agent that lost its machine but still holds authority on
      * the project learns its `repo_id` here.
      */
-    forProject(projectId: string): Promise<GitvaultVaultRecord>;
+    forProject(projectId: string): Promise<VaultRecord>;
     /**
      * Every vault the organization owns, one round trip — `repos list`'s bulk
      * read. See {@link
-     * GitvaultOrgVaultsListing}'s doc comment for the FROZEN response shape and
+     * VaultOrgVaultsListing}'s doc comment for the FROZEN response shape and
      * the 404-until-shipped fallback contract.
      */
-    listByOrg(orgId: string): Promise<GitvaultOrgVaultsListing>;
+    listByOrg(orgId: string): Promise<VaultOrgVaultsListing>;
     /**
      * Resolve a vault by its address-form `org-slug/name` —
-     * `GET /gitvault/v1/vaults?repo=<org-slug>/<name>`.
+     * `GET /vaults/v1?repo=<org-slug>/<name>`.
      * `RESOURCE_NOT_FOUND` for no such org OR no such name (deliberately
      * collapsed — see the design's slug-namespace-probing note);
-     * `SLUG_RELEASED` (read it with {@link gitvaultSlugReleasedInfo}) while the
+     * `SLUG_RELEASED` (read it with {@link vaultSlugReleasedInfo}) while the
      * slug is in its post-rename cooldown — never auto-followed.
      */
     forRepo(address: {
         org_slug: string;
         repo_name: string;
-    }): Promise<GitvaultVaultRecord>;
+    }): Promise<VaultRecord>;
     /**
-     * Resolve a parsed remote address (`parseGitvaultRemoteUrl`'s output),
+     * Resolve a parsed remote address (`parseVaultRemoteUrl`'s output),
      * dispatching on its form: id-form resolves exactly like
      * {@link forProject}; slug-form resolves via {@link forRepo}. A pure read —
      * no pinning, no creation. Node-only callers wanting BOTH should use
      * {@link resolveOrCreateAddress} instead, which also drives the local pin
      * and (opt-in) push-to-create.
      */
-    resolveAddress(address: GitvaultRemoteAddress): Promise<GitvaultVaultRecord>;
+    resolveAddress(address: VaultRemoteAddress): Promise<VaultRecord>;
     /**
      * One page of the heads listing (D186).
      *
@@ -1235,7 +1235,7 @@ export declare class Gitvault {
      * parse. A malformed or stale cursor is `INVALID_CURSOR`; recover by
      * restarting from `after_generation` with no cursor.
      */
-    heads(repoId: string, request: GitvaultHeadsListingRequest): Promise<GitvaultHeadsListingPage>;
+    heads(repoId: string, request: VaultHeadsListingRequest): Promise<VaultHeadsListingPage>;
     /**
      * Walk the whole listing above the anchor, verifying page coupling, ordering,
      * and gaplessness as it goes (a gap is `CHAIN_BROKEN`, never a silent skip).
@@ -1244,7 +1244,7 @@ export declare class Gitvault {
         after_generation: string;
         limit?: string;
     }): Promise<{
-        heads: GitvaultHeadsListingPage["heads"];
+        heads: VaultHeadsListingPage["heads"];
         pages: number;
         total: string | null;
     }>;
@@ -1254,11 +1254,11 @@ export declare class Gitvault {
      * `required`.
      */
     setPolicy(repoId: string, input: {
-        gitvault_policy: "required" | "grandfathered";
+        vault_policy: "required" | "grandfathered";
         reason?: string;
     }): Promise<{
-        gitvault_policy: string;
-        gitvault_policy_version: string;
+        vault_policy: string;
+        vault_policy_version: string;
         changed: boolean;
         warnings: {
             kind: string;
@@ -1272,7 +1272,7 @@ export declare class Gitvault {
      */
     completeOverride(repoId: string, input: {
         operation_id: string;
-        capture_receipt: GitvaultCaptureReceipt;
+        capture_receipt: VaultCaptureReceipt;
     }): Promise<{
         operation_id: string;
         advisory_cleared: boolean;
@@ -1287,14 +1287,14 @@ export declare class Gitvault {
      * it in an agent-surface result store.
      */
     /** `POST …/recipients/:principal_id/confirm` (D197) — first-seen pin confirmation. */
-    confirmRecipient(repoId: string, principalId: string, newFingerprint: string): Promise<GitvaultRecipientConfirmationReceipt>;
+    confirmRecipient(repoId: string, principalId: string, newFingerprint: string): Promise<VaultRecipientConfirmationReceipt>;
     /** `POST …/recipients/:principal_id/repin` (D197) — re-pin ceremony. */
     repinRecipient(repoId: string, principalId: string, input: {
         old_ek_fingerprint: string;
         new_fingerprint: string;
-    }): Promise<GitvaultRecipientConfirmationReceipt>;
+    }): Promise<VaultRecipientConfirmationReceipt>;
     /**
-     * gitvault-agent-envelopes D3 — a KEY-HOLDER explicitly accepts a recipient's
+     * vault-agent-envelopes D3 — a KEY-HOLDER explicitly accepts a recipient's
      * CHANGED key. The session-start reconcile refuses to wrap under a
      * fingerprint that differs from this keystore's TOFU pin
      * (`pinned_key_mismatch`) — that refusal is the substitution defence and
@@ -1308,7 +1308,7 @@ export declare class Gitvault {
      * `new_fingerprint` is not what the org directory currently serves for the
      * principal (a stale or mistyped fingerprint never pins).
      */
-    acceptRecipientKeyChange(options: GitvaultVaultHandleOptions & {
+    acceptRecipientKeyChange(options: VaultHandleOptions & {
         principal_id: string;
         new_fingerprint: string;
     }): Promise<{
@@ -1316,7 +1316,7 @@ export declare class Gitvault {
         principal_id: string;
         old_fingerprint: string | null;
         new_fingerprint: string;
-        receipt: GitvaultRecipientConfirmationReceipt | null;
+        receipt: VaultRecipientConfirmationReceipt | null;
     }>;
     /**
      * `POST …/recipients/:principal_id/key-revocation` (D199) — declares
@@ -1361,7 +1361,7 @@ export declare class Gitvault {
      *
      * Self-match only: the gateway requires `principalId` to equal the
      * AUTHENTICATED caller, never overridable by any credential class — a
-     * mismatch is the ordinary 403 `GITVAULT_ACCESS_DENIED`. Idempotent on
+     * mismatch is the ordinary 403 `VAULT_ACCESS_DENIED`. Idempotent on
      * `(repo_id, principal_id, ek_fingerprint, decryptable_to_generation)` —
      * `deduplicated: true` means the gateway returned the tuple's EXISTING
      * receipt (HTTP 200) rather than minting a fresh one (HTTP 201).
@@ -1372,22 +1372,22 @@ export declare class Gitvault {
         decryptable_to_generation: string;
         reader_entrypoint: string;
     }): Promise<{
-        receipt: GitvaultOpenReceipt;
+        receipt: VaultOpenReceipt;
         deduplicated: boolean;
     }>;
-    acquireMaintenanceLease(request: GitvaultMaintenanceLeaseRequest): Promise<GitvaultMaintenanceLease>;
+    acquireMaintenanceLease(request: VaultMaintenanceLeaseRequest): Promise<VaultMaintenanceLease>;
     /**
      * Open the vault: keystore + HTTP transport + the protocol object. Every verb
      * below builds on this; call it directly when you need the raw protocol
      * surface (ref transactions, repair, checkpoint building).
      */
-    open(options?: GitvaultVaultHandleOptions): Promise<GitvaultHandle>;
+    open(options?: VaultHandleOptions): Promise<VaultHandle>;
     /**
      * Open a vault, allocating it first when it does not exist yet (D2 — lazy
      * allocation on first push).
      *
      * This is the ONE primitive the remote helper and the capture lane
-     * (`run402 gitvault push`/`snapshot`) drive so that a push against an
+     * (`run402 repos capture`/`snapshot`) drive so that a push against an
      * unallocated project runs the six-stage creation journal inline instead of
      * refusing: it resolves `repo_id` from `project_id` exactly like
      * {@link open}, and when that resolution fails, tries to create the vault —
@@ -1405,38 +1405,38 @@ export declare class Gitvault {
      * one vault exists either way. An explicit `client_creation_id` (tests, or
      * a caller resuming a specific attempt by hand) always wins over that search.
      */
-    openOrCreate(options: GitvaultVaultHandleOptions & {
+    openOrCreate(options: VaultHandleOptions & {
         org_id?: string;
         client_creation_id?: string;
-    }): Promise<GitvaultOpenOrCreateResult>;
+    }): Promise<VaultOpenOrCreateResult>;
     /**
      * Resolve a parsed remote address to an OPEN handle, pinning `repo_id` in
      * local git state on the first successful resolution of EITHER form
-     * (gitvault-client-round-trips design D4 widens the original slug-form-only
+     * (vault-client-round-trips design D4 widens the original slug-form-only
      * pin to id-form too — an id-form address needs no pin to survive a
      * rename, but the resolution round trip it skips is the same either way),
      * and — when `allow_create` is set and resolution misses — push-to-create
-     * it. This is what the remote helper and `gitvault snapshot` drive for a
+     * it. This is what the remote helper and `vault snapshot` drive for a
      * `run402::<org>/<name>` remote, whichever form it names, so a caller need
      * not branch on the address's form itself. A pinned id/address that no
      * longer resolves (404) clears the pin and re-resolves once.
      *
      * `SLUG_RELEASED` is NEVER auto-followed — it rethrows unchanged; read it
-     * with {@link gitvaultSlugReleasedInfo} for the successor slug and cooldown.
+     * with {@link vaultSlugReleasedInfo} for the successor slug and cooldown.
      */
-    resolveOrCreateAddress(options: GitvaultVaultHandleOptions & {
-        address: GitvaultRemoteAddress;
+    resolveOrCreateAddress(options: VaultHandleOptions & {
+        address: VaultRemoteAddress;
         /** Push-to-create on a slug-form miss (D6). `false` (default): a miss is an ordinary not-found refusal — the read path (`list`/`fetch`, `status`). */
         allow_create?: boolean;
         client_creation_id?: string;
         /** Fires once, only when THIS call allocated the vault. Awaited before the handle is returned. */
-        onVaultCreated?: (created: NonNullable<import("../node/gitvault-address.js").GitvaultAddressResolution["created"]>) => void | Promise<void>;
-    }): Promise<GitvaultOpenOrCreateResult & {
-        resolution: import("../node/gitvault-address.js").GitvaultAddressResolution;
+        onVaultCreated?: (created: NonNullable<import("../node/vault-address.js").VaultAddressResolution["created"]>) => void | Promise<void>;
+    }): Promise<VaultOpenOrCreateResult & {
+        resolution: import("../node/vault-address.js").VaultAddressResolution;
     }>;
     /**
      * Stale-pin recovery for OFFLINE address resolutions
-     * (gitvault-force-spelling-and-pin-fold): an id-carrying pin resolves with
+     * (vault-force-spelling-and-pin-fold): an id-carrying pin resolves with
      * zero network reads, so a pin gone stale (its vault deleted and the
      * project re-allocated a new one) surfaces as the VERB's first repo-scoped
      * read failing rather than as a resolution failure. Call this with that
@@ -1447,13 +1447,13 @@ export declare class Gitvault {
      * original refusal is real; it is restored, and recovery never widens what
      * an unauthorized caller learns).
      */
-    recoverStalePin(options: GitvaultVaultHandleOptions & {
-        address: GitvaultRemoteAddress;
+    recoverStalePin(options: VaultHandleOptions & {
+        address: VaultRemoteAddress;
         repo_dir: string;
-        resolution: import("../node/gitvault-address.js").GitvaultAddressResolution;
+        resolution: import("../node/vault-address.js").VaultAddressResolution;
         error: unknown;
-    }): Promise<(GitvaultOpenOrCreateResult & {
-        resolution: import("../node/gitvault-address.js").GitvaultAddressResolution;
+    }): Promise<(VaultOpenOrCreateResult & {
+        resolution: import("../node/vault-address.js").VaultAddressResolution;
     }) | null>;
     /**
      * Create the vault for a project and scaffold the git remote.
@@ -1478,7 +1478,7 @@ export declare class Gitvault {
         scaffold_git?: boolean;
         /**
          * Scaffold `repo_dir` as its OWN repository even when it lies inside
-         * another one (see {@link Gitvault.scaffoldRemote}'s `nested`). Default
+         * another one (see {@link Repos.scaffoldRemote}'s `nested`). Default
          * `false`: an app root inside another repository is reported `skipped`.
          */
         nested?: boolean;
@@ -1486,22 +1486,22 @@ export declare class Gitvault {
         remote_url?: string;
         service_public_key?: Uint8Array | string;
         /**
-         * gitvault-byo-primary-bucket task 3.1/3.2/3.5 — request a BYO vault.
+         * vault-byo-primary-bucket task 3.1/3.2/3.5 — request a BYO vault.
          * Same raw-string shape `mirrorSet` already takes (`destination_url` +
          * `credential` + `region`/`endpoint`), so a CLI edge stays a thin
          * adapter — no destination parsing lives outside the SDK. Omitted (the
          * default) is byte-identical to today. This method RUNS the
          * allocation-time bucket probe (D6) itself, BEFORE any allocation
-         * request — a failed probe throws `GITVAULT_BYO_BUCKET_PROBE_FAILED`
+         * request — a failed probe throws `VAULT_BYO_BUCKET_PROBE_FAILED`
          * and nothing is created.
          */
         byo?: {
             destination_url: string;
-            credential?: import("../node/gitvault-mirror-config.js").GitvaultMirrorCredential;
+            credential?: import("../node/vault-mirror-config.js").VaultMirrorCredential;
             region?: string;
             endpoint?: string;
         };
-    }): Promise<GitvaultInitResult>;
+    }): Promise<VaultInitResult>;
     /**
      * Add the run402 git remote, initialising the repository if absent.
      *
@@ -1543,7 +1543,7 @@ export declare class Gitvault {
         remote_name?: string;
         remote_url?: string;
         nested?: boolean;
-    }): Promise<GitvaultScaffoldRemoteResult>;
+    }): Promise<VaultScaffoldRemoteResult>;
     /**
      * What this machine and the control plane each believe about the vault.
      *
@@ -1551,7 +1551,7 @@ export declare class Gitvault {
      * deployed raises no deploy-related warning, and the terminal-loss statement
      * is stated verbatim exactly as for any other vault.
      */
-    status(options?: GitvaultVaultHandleOptions & {
+    status(options?: VaultHandleOptions & {
         /**
          * Also report the vault's ref map and HEAD target.
          *
@@ -1561,7 +1561,7 @@ export declare class Gitvault {
          * observation, which is what makes it safe to run anywhere.
          */
         refs?: boolean;
-    }): Promise<GitvaultStatus>;
+    }): Promise<VaultStatus>;
     /**
      * Capture the working tree and publish it — the push half of a deploy, run on
      * its own. Never gated on a deploy: a vault-only project pushes for months
@@ -1575,7 +1575,7 @@ export declare class Gitvault {
      * charges with reproducing them ("the helper SHALL reproduce the exact set of
      * objects reachable from the declared canonical refs (`refs/heads/*`,
      * `refs/tags/*`, protocol-owned `refs/run402/*`), plus the `HEAD` target" —
-     * gitvault-client-surface, "Faithful helper"; `run402 gitvault push` is
+     * vault-client-surface, "Faithful helper"; `run402 repos capture` is
      * separately defined as "capture and push outside a deploy" under "Source
      * verbs"). The split is forced by §6.6: a dirty tree captures as a SYNTHETIC
      * commit that sits on no branch, so moving `refs/heads/main` onto it would
@@ -1591,27 +1591,27 @@ export declare class Gitvault {
      * against its expected manifest and reads the admitted head back from
      * storage. A 200 alone is never enough (§0 client obligations).
      */
-    push(options: GitvaultVaultHandleOptions & {
+    capture(options: VaultHandleOptions & {
         /**
          * The owning org. Supply it to run D2's lazy allocation: when this
-         * project's vault does not exist yet, push() runs the six-stage
+         * project's vault does not exist yet, capture() runs the six-stage
          * creation journal inline (via {@link openOrCreate}) before capturing
-         * and publishing — one command, no prior `gitvault init`. Without it,
-         * push() behaves exactly as it always did: a push against an
+         * and publishing — one command, no prior `vault init`. Without it,
+         * capture() behaves exactly as it always did: a push against an
          * unallocated vault throws the resolution failure unchanged.
          */
         org_id?: string;
         /**
-         * A parsed remote address (`parseGitvaultRemoteUrl`'s output).
+         * A parsed remote address (`parseVaultRemoteUrl`'s output).
          * When given, this push resolves
          * (and, for a slug-form address, pins) through
          * {@link resolveOrCreateAddress} INSTEAD of `openOrCreate`'s
          * project_id-based path; `org_id`/`project_id`/`repo_id` are ignored.
          * Mirrors `git push`'s own push-to-create dispatch in the remote
-         * helper, for callers (`gitvault snapshot`) that resolve the target
+         * helper, for callers (`vault snapshot`) that resolve the target
          * from the local git remote instead of `--project`.
          */
-        address?: GitvaultRemoteAddress;
+        address?: VaultRemoteAddress;
         /** Resume a specific creation attempt (or pin it in tests); auto-discovered from the local keystore otherwise. */
         client_creation_id?: string;
         /**
@@ -1621,7 +1621,7 @@ export declare class Gitvault {
          * resolving the keystore path to print) completes and stays ordered
          * BEFORE the rest of this push's own output.
          */
-        onVaultCreated?: (created: NonNullable<GitvaultOpenOrCreateResult["created"]>) => void | Promise<void>;
+        onVaultCreated?: (created: NonNullable<VaultOpenOrCreateResult["created"]>) => void | Promise<void>;
         /**
          * Capture options, forwarded verbatim to `captureSnapshot`. The commit
          * message for the synthetic commit a dirty tree produces lives HERE
@@ -1629,22 +1629,22 @@ export declare class Gitvault {
          * `message` field, because a `snapshot` passthrough plus a sibling
          * shortcut is two ways to say one thing with no defined precedence.
          */
-        snapshot?: Omit<import("../node/gitvault-snapshot.js").GitvaultSnapshotOptions, "dir">;
+        snapshot?: Omit<import("../node/vault-snapshot.js").VaultSnapshotOptions, "dir">;
         onCommitLine?: (line: string) => void;
         checkpoint?: boolean;
-    }): Promise<GitvaultPublishResult & {
-        snapshot: GitvaultSnapshot;
-        gitvault_commit: string;
-        gitvault_commit_line: string;
-        mirror_push: GitvaultMirrorPushResult;
-        byo_chain_copy: GitvaultMirrorPushResult;
-        reconcile_recipients: GitvaultReconcileEnvelopeRecipientsPushResult;
-        writer_reconcile: GitvaultReconcileWriterAdmissionsPushResult;
+    }): Promise<VaultPublishResult & {
+        snapshot: VaultSnapshot;
+        vault_commit: string;
+        vault_commit_line: string;
+        mirror_push: VaultMirrorPushResult;
+        byo_chain_copy: VaultMirrorPushResult;
+        reconcile_recipients: VaultReconcileEnvelopeRecipientsPushResult;
+        writer_reconcile: VaultReconcileWriterAdmissionsPushResult;
     }>;
     /**
      * Mint a Handoff Key: capture a stash-shaped checkpoint (design D1),
-     * push it (retained, on no branch — {@link GITVAULT_DEPLOY_REF} carries
-     * it exactly like an ordinary `push()`, never `refs/heads/*`), seal the
+     * push it (retained, on no branch — {@link VAULT_DEPLOY_REF} carries
+     * it exactly like an ordinary `capture()`, never `refs/heads/*`), seal the
      * vault's current epoch key under a fresh `wrap_key`, and mint through
      * the gateway. The assembled `kgh1_…` key is returned exactly ONCE —
      * nothing here or downstream persists it.
@@ -1653,24 +1653,24 @@ export declare class Gitvault {
      * capture figures and runs the client-side secret scan BEFORE the
      * handoff commit is written (design D10: no override flag).
      */
-    handoff(options: GitvaultVaultHandleOptions & {
-        address?: GitvaultRemoteAddress;
+    handoff(options: VaultHandleOptions & {
+        address?: VaultRemoteAddress;
         role?: string;
         ttlSeconds?: number;
-        note: Omit<import("../node/gitvault-handoff.js").KygitHandoffNote, "capture">;
+        note: Omit<import("../node/vault-handoff.js").KygitHandoffNote, "capture">;
         includeSensitive?: string[];
         onCommitLine?: (line: string) => void;
-    }): Promise<GitvaultHandoffMintResult>;
+    }): Promise<VaultHandoffMintResult>;
     /** List a vault's handoffs (ids, kind, state, role, expiry, redeemed_by — never the hash or envelope). */
-    listHandoffs(options: GitvaultVaultHandleOptions): Promise<GitvaultHandoffListResult>;
+    listHandoffs(options: VaultHandleOptions): Promise<VaultHandoffListResult>;
     /** Revoke a handoff (idempotent — a second revoke of an already-revoked/redeemed/expired row still answers `200`). */
-    revokeHandoff(handoffId: string, options: GitvaultVaultHandleOptions): Promise<{
+    revokeHandoff(handoffId: string, options: VaultHandleOptions): Promise<{
         handoff_id: string;
         state: string;
     }>;
     /**
      * Mint an Invite Key: capture a stash-shaped checkpoint exactly as
-     * {@link Gitvault.handoff} does (design D1), push it (retained, on no
+     * {@link Repos.handoff} does (design D1), push it (retained, on no
      * branch), register the INVITER's own presence in the invite's room
      * (design D4 — before the mint, so the row can carry
      * `inviter_presence_id`; a registration failure is reported and the mint
@@ -1688,13 +1688,13 @@ export declare class Gitvault {
      * capture figures and runs the client-side secret scan BEFORE the invite
      * commit is written (design D10/kygit-invite D3: no override flag).
      */
-    invite(options: GitvaultVaultHandleOptions & {
-        address?: GitvaultRemoteAddress;
+    invite(options: VaultHandleOptions & {
+        address?: VaultRemoteAddress;
         role?: string;
         ttlSeconds?: number;
         /** Named org room to invite into. Omitted: the project's default room (its own id). */
         roomKey?: string;
-        note: Omit<import("../node/gitvault-handoff.js").KygitInviteNote, "capture">;
+        note: Omit<import("../node/vault-handoff.js").KygitInviteNote, "capture">;
         includeSensitive?: string[];
         onCommitLine?: (line: string) => void;
         /** Harness-derived presence labels (design D8) — never guessed by the SDK itself. */
@@ -1704,11 +1704,11 @@ export declare class Gitvault {
         sessionKey?: string;
         /** Display-only "what I'm working on" for the inviter's presence. */
         task?: string;
-    }): Promise<GitvaultInviteMintResult>;
+    }): Promise<VaultInviteMintResult>;
     /** List a vault's invites (ids, kind, state, role, room, expiry, redeemed_by — never the hash or envelope). */
-    listInvites(options: GitvaultVaultHandleOptions): Promise<GitvaultInviteListResult>;
+    listInvites(options: VaultHandleOptions): Promise<VaultInviteListResult>;
     /** Revoke an invite (idempotent — a second revoke of an already-revoked/redeemed/expired row still answers `200`). */
-    revokeInvite(inviteId: string, options: GitvaultVaultHandleOptions): Promise<{
+    revokeInvite(inviteId: string, options: VaultHandleOptions): Promise<{
         invite_id: string;
         state: string;
     }>;
@@ -1723,7 +1723,7 @@ export declare class Gitvault {
      * envelope supersedes the bearer one.
      */
     /**
-     * gitvault-multi-writer rev 47 (task 5.6, design D4/D5) — order: parse →
+     * vault-multi-writer rev 47 (task 5.6, design D4/D5) — order: parse →
      * ensure wallet → ensure identity → derive auth/wrap/admission → build
      * acceptance → redeem → verify grant → open envelope → check the grant
      * hash → persist repo file with `pending_writer_admission` → clone →
@@ -1750,11 +1750,11 @@ export declare class Gitvault {
         to?: string;
         keystore_root?: string;
         onLine?: (line: string) => void;
-    }): Promise<GitvaultHandoffResumeResult>;
+    }): Promise<VaultHandoffResumeResult>;
     /**
      * Join an Invite Key: parse (refusing a `kgh1_` handoff key by name,
      * pointing at `resume` — design D9) → ensure this machine has a wallet
-     * (design D5, mirroring {@link Gitvault.resume}'s own bare-wallet
+     * (design D5, mirroring {@link Repos.resume}'s own bare-wallet
      * backstop; the CALLER folds the fuller cold-start chain — wallet,
      * faucet, one x402 prototype payment — before invoking this, never
      * blocking the redemption itself) → redeem → open the sealed envelope → write
@@ -1781,13 +1781,13 @@ export declare class Gitvault {
         task?: string;
         /** How many recent messages to read for the arrival view. Default 10. */
         recentMessagesLimit?: number;
-    }): Promise<GitvaultInviteJoinResult>;
+    }): Promise<VaultInviteJoinResult>;
     /**
      * The capture-time copies a plain `git push` through the remote helper
-     * owes exactly as {@link push} and {@link deploy} do: the opt-in mirror
+     * owes exactly as {@link capture} and {@link deploy} do: the opt-in mirror
      * dual-push and, on a BYO vault, the signed-chain copy into the customer
-     * bucket (gitvault-byo-primary-bucket task 3.3). The helper publishes
-     * through `GitvaultVault.push` directly, so it calls this right after a
+     * bucket (vault-byo-primary-bucket task 3.3). The helper publishes
+     * through `Vault.push` directly, so it calls this right after a
      * generation lands. Same contract as the private hooks it composes:
      * best-effort, NEVER throws, never alters the push already committed —
      * each outcome is reported on its own field (`skipped_no_mirror` costs no
@@ -1795,20 +1795,20 @@ export declare class Gitvault {
      */
     postPublishCopies(input: {
         repo_id: string;
-        keystore: GitvaultKeystore;
+        keystore: VaultKeystore;
     }): Promise<{
-        mirror_push: GitvaultMirrorPushResult;
-        byo_chain_copy: GitvaultMirrorPushResult;
+        mirror_push: VaultMirrorPushResult;
+        byo_chain_copy: VaultMirrorPushResult;
     }>;
     /**
-     * A REAL preview of what {@link push} would publish
-     * — never publishes anything, and never allocates. `run402 gitvault
-     * snapshot --dry-run` and `git-remote-run402`'s `option dry-run true` are
+     * A REAL preview of what {@link capture} would publish
+     * — never publishes anything, and never allocates. `run402 repos
+     * capture --dry-run` and `git-remote-run402`'s `option dry-run true` are
      * both thin adapters over this method.
      *
      * "Refusing beats fake success" (this file's own architectural law) governs
      * the shape of what happens when the vault does not exist yet: unlike
-     * {@link push}, this NEVER allocates one (push-to-create must not allocate
+     * {@link capture}, this NEVER allocates one (push-to-create must not allocate
      * on a dry run) — it resolves READ-ONLY (`open`/`resolveOrCreateAddress`
      * with `allow_create: false`), and when that resolution misses, returns
      * `allocation_needed: true` with every sizing field `null` rather than a
@@ -1819,21 +1819,21 @@ export declare class Gitvault {
      *
      * Everything else is the SAME real local pipeline `push` runs — capture,
      * pack building, sealing/encryption — computed by
-     * {@link import("../node/gitvault-publication.js").GitvaultVault.planPush},
+     * {@link import("../node/vault-publication.js").Vault.planPush},
      * which is what actually stops short of the two network mutations
      * (`uploadObjects`, `admitHead`). See its doc comment for what
      * `would_admit_generation` does and does not promise.
      */
-    planPush(options: GitvaultVaultHandleOptions & {
-        /** Same as {@link push}'s `address` — a parsed remote address. Resolved READ-ONLY (`allow_create: false`); never push-to-creates. */
-        address?: GitvaultRemoteAddress;
-        snapshot?: Omit<import("../node/gitvault-snapshot.js").GitvaultSnapshotOptions, "dir">;
+    planCapture(options: VaultHandleOptions & {
+        /** Same as {@link capture}'s `address` — a parsed remote address. Resolved READ-ONLY (`allow_create: false`); never push-to-creates. */
+        address?: VaultRemoteAddress;
+        snapshot?: Omit<import("../node/vault-snapshot.js").VaultSnapshotOptions, "dir">;
         onCommitLine?: (line: string) => void;
         checkpoint?: boolean;
-    }): Promise<GitvaultSnapshotPushPlan>;
+    }): Promise<VaultSnapshotPushPlan>;
     /**
      * Compaction's transient-storage preflight
-     * (gitvault-compaction-headroom-preflight, design D1/D2).
+     * (vault-compaction-headroom-preflight, design D1/D2).
      *
      * Three postures, in order of information quality:
      *   1. the check answers "won't fit" → typed refusal, before any upload;
@@ -1857,19 +1857,19 @@ export declare class Gitvault {
      * runs but the numbers are just as worth showing. `null` when the pooled
      * figures cannot be read.
      */
-    compactHeadroom(options?: GitvaultVaultHandleOptions): Promise<GitvaultCompactHeadroom | null>;
+    compactHeadroom(options?: VaultHandleOptions): Promise<VaultCompactHeadroom | null>;
     /**
-     * Open this vault's compaction headroom grant directly (gitvault-checkpoint-cadence
+     * Open this vault's compaction headroom grant directly (vault-checkpoint-cadence
      * design D3) — `compact()` already does this internally; this standalone
      * entry point exists for callers that need to inspect or drive the grant
      * without also running a full compaction cycle (tests; a future
-     * operator/diagnostic surface). Throws `GITVAULT_COMPACTION_GRANT_ACTIVE`
+     * operator/diagnostic surface). Throws `VAULT_COMPACTION_GRANT_ACTIVE`
      * (409) verbatim when another compaction already holds this project's
      * grant.
      */
-    openCompactionGrant(options?: GitvaultVaultHandleOptions): Promise<GitvaultCompactionGrant>;
+    openCompactionGrant(options?: VaultHandleOptions): Promise<VaultCompactionGrant>;
     /** Close this vault's compaction headroom grant directly — idempotent; `{closed: false}` when nothing was active. */
-    closeCompactionGrant(options?: GitvaultVaultHandleOptions): Promise<{
+    closeCompactionGrant(options?: VaultHandleOptions): Promise<{
         closed: boolean;
     }>;
     /**
@@ -1882,7 +1882,7 @@ export declare class Gitvault {
      * A repository beyond the V0 checkpoint maximum is refused at preflight with
      * `CHECKPOINT_SET_LIMIT_EXCEEDED`.
      */
-    compact(options?: GitvaultVaultHandleOptions & {
+    compact(options?: VaultHandleOptions & {
         /** Skip the lease entirely (single-writer situations, tests). */
         lease?: boolean;
         /**
@@ -1902,7 +1902,7 @@ export declare class Gitvault {
          * refusal. CLI: `--force-headroom`.
          */
         ignoreHeadroom?: boolean;
-    }): Promise<GitvaultCompactResult>;
+    }): Promise<VaultCompactResult>;
     /**
      * Plan a prune — and, with both verifier receipts in hand, submit it.
      *
@@ -1924,7 +1924,7 @@ export declare class Gitvault {
      * completion and nothing else. `present_after_attempt` is a FAILED deletion
      * and is never counted as one.
      */
-    prune(options?: GitvaultVaultHandleOptions & {
+    prune(options?: VaultHandleOptions & {
         now?: () => Date;
         /**
          * `effective_admitted_at` for a root's drop generation, or `null` when
@@ -1940,15 +1940,15 @@ export declare class Gitvault {
          * that core's `intent_core_sha256`.
          */
         submit?: {
-            core: import("../node/gitvault-prune.js").GitvaultPruneIntentCore;
-            verifier_receipt: import("../node/gitvault-prune.js").GitvaultVerifierReceipt;
+            core: import("../node/vault-prune.js").VaultPruneIntentCore;
+            verifier_receipt: import("../node/vault-prune.js").VaultVerifierReceipt;
             /** Poll budget for the signed completion. Absent ⇒ submit and report the intent without waiting. */
             wait?: {
                 attempts?: number;
                 interval_ms?: number;
             };
         };
-    }): Promise<GitvaultPruneResult>;
+    }): Promise<VaultPruneResult>;
     /**
      * Verify the head chain from the authenticated pin up to the newest listed
      * generation, then return the verified state.
@@ -1959,9 +1959,9 @@ export declare class Gitvault {
      * budget is resumable — a `VERIFICATION_BUDGET_EXCEEDED` client continues
      * from its verified prefix rather than restarting.
      */
-    verify(options?: GitvaultVaultHandleOptions & {
+    verify(options?: VaultHandleOptions & {
         persist?: boolean;
-    }): Promise<GitvaultVerifiedState>;
+    }): Promise<VaultVerifiedState>;
     /**
      * `repos fsck` (repo-surface-consolidation D2/D3): walk the head chain
      * AND materialize the ref map, reporting
@@ -1990,52 +1990,50 @@ export declare class Gitvault {
      * bare "verified": `chain_verified_to_generation` and
      * `decryptable_to_generation` are reported separately and can genuinely
      * differ — the incident-shape truth ("chain verified to 10, decryptable
-     * to 7, `GITVAULT_EPOCH_NOT_OPENABLE` at epoch 2/rotation …") is exactly
+     * to 7, `VAULT_EPOCH_NOT_OPENABLE` at epoch 2/rotation …") is exactly
      * what this split makes representable. `refs`/`head_target`/
      * `pin_after.highest_materialized` all reflect `decryptable_to_generation`.
      *
-     * **gitvault-byo-primary-bucket task 3.3 (design D6).** For a
+     * **vault-byo-primary-bucket task 3.3 (design D6).** For a
      * `storage_profile: "byo"` vault, `fsck` ALSO adjudicates the customer's
      * own bucket against run402's signed chain — see {@link
      * #checkByoPresence} for the full contract (automatic, never a flag;
      * fails soft with no local credentials; throws
-     * `GITVAULT_BYO_OBJECT_MISSING` on a confirmed absence). A managed vault
+     * `VAULT_BYO_OBJECT_MISSING` on a confirmed absence). A managed vault
      * is byte-identical to before this task.
      */
-    fsck(options?: GitvaultVaultHandleOptions & {
+    fsck(options?: VaultHandleOptions & {
         write?: boolean;
         mirror?: boolean;
-    }): Promise<GitvaultFsckResult>;
+    }): Promise<VaultFsckResult>;
     /**
      * Wrap this vault's current epoch key to every org member who has
      * published an encryption key but has no `key_envelope` on this vault yet
-     * — gitvault-human-envelopes task 4.1's ADD-path workaround. See {@link
-     * import("../node/gitvault-publication.js").GitvaultVault.
+     * — vault-human-envelopes task 4.1's ADD-path workaround. See {@link
+     * import("../node/vault-publication.js").Vault.
      * reconcileEnvelopeRecipients} for the full design (TOFU pinning, the
      * gateway `public_key` gap, and why this is a workaround rather than the
      * eventual epoch-rotation design).
      *
-     * `run402 gitvault reconcile` has no `repos` equivalent — `reconcile` is
-     * a workaround, not a permanent verb — and answers `COMMAND_REMOVED`
-     * pointing at `repos access` for inspection. This method itself stays:
-     * `deploy()` runs it, best-effort,
+     * No CLI verb runs this directly — `repos access` is the inspection
+     * read. `deploy()` runs it, best-effort,
      * whenever a deploy lands a new generation in the vault — design D5's
      * "deploy time" hook, "the same 'one command every agent runs' argument
-     * that decided deploy-implies-capture." `push()` (capture-and-publish
+     * that decided deploy-implies-capture." `capture()` (capture-and-publish
      * outside a deploy) runs the identical hook after every successful
      * publish, for the vault-only-project cadence. See
      * `#tryReconcileEnvelopeRecipients` below for both call sites, and
-     * {@link Gitvault.access} for the READ half repo-surface-consolidation
+     * {@link Repos.access} for the READ half repo-surface-consolidation
      * ships in its place.
      */
-    reconcileEnvelopeRecipients(options?: GitvaultVaultHandleOptions): Promise<GitvaultReconcileEnvelopeRecipientsResult>;
+    reconcileEnvelopeRecipients(options?: VaultHandleOptions): Promise<VaultReconcileEnvelopeRecipientsResult>;
     /**
-     * gitvault-multi-writer (task 5.7) — admit every eligible `pending_writers[]`
+     * vault-multi-writer (task 5.7) — admit every eligible `pending_writers[]`
      * candidate (active org membership at role developer+, a published,
      * possession-verified signing key, not yet in the writer set) via a fresh
      * `add_writer_key{"writer"}` head per candidate. This session's OWN key
      * must already be an active writer — see {@link
-     * import("../node/gitvault-publication.js").GitvaultVault.
+     * import("../node/vault-publication.js").Vault.
      * reconcileWriterAdmissions}'s doc comment for why that is checked
      * locally, once, rather than surfaced as N identical gateway refusals.
      *
@@ -2046,7 +2044,7 @@ export declare class Gitvault {
      * `already_covered`, never re-admitted), mirroring {@link
      * reconcileEnvelopeRecipients}'s own identical redundancy-tolerant shape.
      */
-    reconcile(options?: GitvaultVaultHandleOptions): Promise<GitvaultReconcileWriterAdmissionsResult>;
+    reconcile(options?: VaultHandleOptions): Promise<VaultReconcileWriterAdmissionsResult>;
     /**
      * Drive one epoch rotation (D193-D203, rev 42) — the client half of
      * epoch rotation: sample a fresh `K_e`, compute the H-partition from live
@@ -2055,7 +2053,7 @@ export declare class Gitvault {
      * `rotation_attempt_descriptor`, submit the `rotate_epoch` head, verify
      * this principal's own envelope opens to the committed key (when it is
      * itself a recipient), and advance the local keystore's epoch pointer.
-     * See {@link import("../node/gitvault-publication.js").GitvaultVault.
+     * See {@link import("../node/vault-publication.js").Vault.
      * rotateEpoch}'s own doc comment for the full obligations and — load-
      * bearing — the confirmed gap in what the gateway exposes for
      * `recipient_state_version`/`recipient_revocation_version` outside the
@@ -2064,17 +2062,17 @@ export declare class Gitvault {
      * result into THIS rotation's head instead of a separately-gated
      * `publishPinManifestUpdate` call.
      */
-    rotateEpoch(options: GitvaultVaultHandleOptions & {
-        reason: GitvaultRotationReason;
+    rotateEpoch(options: VaultHandleOptions & {
+        reason: VaultRotationReason;
         recipient_state_version: string;
         recipient_revocation_version: string;
         client_idempotency_key?: string;
         pending_confirmations?: {
             principal_id: string;
             ek_fingerprint: string;
-            receipt: GitvaultRecipientConfirmationReceipt;
+            receipt: VaultRecipientConfirmationReceipt;
         }[];
-    }): Promise<import("../node/gitvault-publication.js").GitvaultRotationResult>;
+    }): Promise<import("../node/vault-publication.js").VaultRotationResult>;
     /**
      * The ONE fully self-contained rotation entry point: declares
      * `reason:"recipient_key_revoked"` for `principalId` (owner + step-up)
@@ -2085,18 +2083,18 @@ export declare class Gitvault {
      */
     /**
      * The writer-capable rotation that completes an org membership removal
-     * (`reason:"member_removed"`, gitvault-multi-writer D6): counters come off
+     * (`reason:"member_removed"`, vault-multi-writer D6): counters come off
      * the envelope-recipients read, no declaration, no owner step-up — any
-     * surviving writer can run it. `push()` runs it automatically when the
+     * surviving writer can run it. `capture()` runs it automatically when the
      * gate names an outstanding removal; this is the explicit entry point
-     * (`run402 org member rm` drives it on every vault the caller can).
+     * (`run402 orgs members rm` drives it on every vault the caller can).
      */
-    rotateEpochForMemberRemoval(options?: GitvaultVaultHandleOptions & {
+    rotateEpochForMemberRemoval(options?: VaultHandleOptions & {
         client_idempotency_key?: string;
-    }): Promise<import("../node/gitvault-publication.js").GitvaultRotationResult>;
-    rotateEpochForKeyRevocation(principalId: string, options?: GitvaultVaultHandleOptions & {
+    }): Promise<import("../node/vault-publication.js").VaultRotationResult>;
+    rotateEpochForKeyRevocation(principalId: string, options?: VaultHandleOptions & {
         client_idempotency_key?: string;
-    }): Promise<import("../node/gitvault-publication.js").GitvaultRotationResult>;
+    }): Promise<import("../node/vault-publication.js").VaultRotationResult>;
     /**
      * Publish a receipted `recipient_pin_manifest` update (D197) — the
      * publication half of the `/confirm`/`/repin` ceremonies above. Call
@@ -2116,19 +2114,19 @@ export declare class Gitvault {
     publishPinManifestUpdate(input: {
         principal_id: string;
         ek_fingerprint: string;
-        receipt: GitvaultRecipientConfirmationReceipt;
-    } & GitvaultVaultHandleOptions): Promise<import("../node/gitvault-publication.js").GitvaultPublishResult>;
+        receipt: VaultRecipientConfirmationReceipt;
+    } & VaultHandleOptions): Promise<import("../node/vault-publication.js").VaultPublishResult>;
     /**
      * `repos access` (repo-surface-consolidation D5/D10) — a READ-ONLY report
      * of who can open this vault, composed from whatever the live gateway
      * surface exposes today. Never wraps, never mutates a `key_envelope` —
      * that mutating half stays {@link reconcileEnvelopeRecipients}, reachable
      * only through the deploy/push best-effort hooks until `access repair`
-     * ships (gated on `gitvault-human-envelopes`' epoch-rotation work). See
-     * {@link GitvaultAccessResult}'s doc comment for the honest gap this
+     * ships (gated on `vault-human-envelopes`' epoch-rotation work). See
+     * {@link VaultAccessResult}'s doc comment for the honest gap this
      * reports rather than invents.
      */
-    access(options?: GitvaultVaultHandleOptions): Promise<GitvaultAccessResult>;
+    access(options?: VaultHandleOptions): Promise<VaultAccessResult>;
     /**
      * The push-gated deploy: both lanes under one fresh `capture_id`, resolving
      * to exactly one of five outcomes — `DEPLOYED_AND_VAULTED`,
@@ -2142,42 +2140,42 @@ export declare class Gitvault {
      * `run402 deploy` is design D5's PRIMARY envelope-recipient reconcile hook
      * ("the same 'one command every agent runs' argument that decided
      * deploy-implies-capture") and design D6's primary dual-push mirror trigger
-     * — both fire HERE, not inside {@link runGitvaultDeploy} itself, mirroring
-     * {@link push}'s exact non-blocking contract: best-effort, NEVER throw,
+     * — both fire HERE, not inside {@link runVaultDeploy} itself, mirroring
+     * {@link capture}'s exact non-blocking contract: best-effort, NEVER throw,
      * NEVER alter the deploy outcome already resolved above, reported BESIDE it
      * on `mirror_push` / `reconcile_recipients`. They fire only when this
      * deploy actually landed a new generation in the vault
      * (`DEPLOYED_AND_VAULTED` / `DEPLOY_FAILED_VAULTED` — the outcomes carrying
      * a `generation`); the other three outcomes published nothing new, so
      * there is nothing to mirror or reconcile against ({@link
-     * import("../node/gitvault-mirror.js").mirrorPushForGeneration}'s own
+     * import("../node/vault-mirror.js").mirrorPushForGeneration}'s own
      * contract: "fires after an ordinary vault push/deploy produces a new
      * generation"). Both fields are therefore OMITTED — never a faked
      * `skipped_*` outcome — when no generation landed.
      */
-    deploy(options: Omit<GitvaultDeployOptions, "vault"> & GitvaultVaultHandleOptions): Promise<GitvaultDeployResult & {
-        mirror_push?: GitvaultMirrorPushResult;
-        byo_chain_copy?: GitvaultMirrorPushResult;
-        reconcile_recipients?: GitvaultReconcileEnvelopeRecipientsPushResult;
-        writer_reconcile?: GitvaultReconcileWriterAdmissionsPushResult;
+    deploy(options: Omit<VaultDeployOptions, "vault"> & VaultHandleOptions): Promise<VaultDeployResult & {
+        mirror_push?: VaultMirrorPushResult;
+        byo_chain_copy?: VaultMirrorPushResult;
+        reconcile_recipients?: VaultReconcileEnvelopeRecipientsPushResult;
+        writer_reconcile?: VaultReconcileWriterAdmissionsPushResult;
     }>;
     /**
      * Drain every unvaulted-override journal on this machine: push the exact
      * journaled snapshot and present the capture receipt for full-field
      * comparison. A partial match never clears the advisory.
      */
-    drainOverrides(options?: GitvaultVaultHandleOptions): Promise<import("../node/gitvault-deploy.js").GitvaultOverrideDrainReport>;
+    drainOverrides(options?: VaultHandleOptions): Promise<import("../node/vault-deploy.js").VaultOverrideDrainReport>;
     /**
      * Reproduce the vault's object database into a git repository — the clone-back
      * path. Needs only git and a surviving keystore: no deployment artifact, CAS
      * entry, or apply operation is consulted.
      */
-    restore(options: GitvaultVaultHandleOptions & {
+    restore(options: VaultHandleOptions & {
         target_dir: string;
     }): Promise<{
         refs: Record<string, string>;
         generation: string;
-        retained_refs: import("../node/gitvault-publication.js").GitvaultRetainedRefsReconcileResult;
+        retained_refs: import("../node/vault-publication.js").VaultRetainedRefsReconcileResult;
     }>;
     /**
      * Wrap an ALREADY-RESOLVED vault read with degraded-read fallback: run
@@ -2185,7 +2183,7 @@ export declare class Gitvault {
      * `vault.materialize()` for a `list`-shaped read, or
      * `vault.restoreObjectsInto(dir)` for a `fetch`-shaped one), and on a
      * network-class failure (never on an authorization refusal or any other
-     * 4xx — see `isNetworkClassGitvaultReadError`), fall back to the vault's
+     * 4xx — see `isNetworkClassVaultReadError`), fall back to the vault's
      * configured mirror via the SAME `r402s-recover` engine `recover()` uses.
      *
      * Deliberately takes an already-open `vault`/`keystore`/`repo_id` rather
@@ -2203,20 +2201,20 @@ export declare class Gitvault {
      * e.g. a bare `git ls-remote` outside any checkout) disables the fallback
      * entirely: the original gateway error surfaces exactly as it always did.
      */
-    withDegradedRead<T extends GitvaultDegradedReadLive>(options: {
+    withDegradedRead<T extends VaultDegradedReadLive>(options: {
         attemptLive: () => Promise<T>;
-        keystore: GitvaultKeystore;
+        keystore: VaultKeystore;
         repo_id: string;
         out_dir: string | null;
-    }): Promise<GitvaultDegradedReadOutcome<T>>;
+    }): Promise<VaultDegradedReadOutcome<T>>;
     /**
-     * gitvault-byo-primary-bucket (design D4): the degraded read for the OPEN
+     * vault-byo-primary-bucket (design D4): the degraded read for the OPEN
      * itself. {@link withDegradedRead} wraps a handle's live read, but a plain
      * `git fetch`/`clone` needs the gateway once BEFORE any read — to open the
      * handle (enrollment, the vault record). When that open fails
      * network-class and this checkout already knows the vault — a pinned
      * `repo_id`, or the keystore's own project→repo file for an id-form
-     * address (gitvault-offline-clone-resolve) — the whole read is served from
+     * address (vault-offline-clone-resolve) — the whole read is served from
      * the vault's BYO destination or configured mirror, exactly as
      * `withDegradedRead` would have after a failed live read. `null` when this
      * cannot help (a non-network failure, no local identity for the vault, no
@@ -2226,9 +2224,9 @@ export declare class Gitvault {
     degradedOpenFallback(input: {
         repo_dir: string;
         error: unknown;
-        address?: import("../node/gitvault-address.js").ResolveGitvaultAddressOptions["address"];
+        address?: import("../node/vault-address.js").ResolveVaultAddressOptions["address"];
         repo_id?: string;
-    }): Promise<GitvaultDegradedReadOutcome<GitvaultDegradedReadLive> | null>;
+    }): Promise<VaultDegradedReadOutcome<VaultDegradedReadLive> | null>;
     /**
      * Configure (or replace) the customer-owned mirror destination for one
      * vault. Client-side ONLY — the destination + credential NAME are written
@@ -2236,14 +2234,14 @@ export declare class Gitvault {
      * secret value. `s3://<bucket>/<prefix>` needs `credential`; a plain
      * filesystem path needs none.
      */
-    mirrorSet(options: GitvaultVaultHandleOptions & {
+    mirrorSet(options: VaultHandleOptions & {
         destination_url: string;
-        credential?: GitvaultMirrorCredential;
+        credential?: VaultMirrorCredential;
         region?: string;
         endpoint?: string;
-    }): Promise<GitvaultMirrorConfig>;
+    }): Promise<VaultMirrorConfig>;
     /** Remove the mirror config for one vault. Never touches the mirror's own bytes (design: config removal ≠ data deletion). */
-    mirrorRemove(options?: GitvaultVaultHandleOptions): Promise<{
+    mirrorRemove(options?: VaultHandleOptions): Promise<{
         repo_id: string;
         removed: boolean;
     }>;
@@ -2254,13 +2252,13 @@ export declare class Gitvault {
      * read of the vault record), and — when they disagree — the closing
      * command. Both honesty statements (design D8) ride every response.
      */
-    mirrorStatus(options?: GitvaultVaultHandleOptions & {
+    mirrorStatus(options?: VaultHandleOptions & {
         is_byo?: boolean;
-    }): Promise<GitvaultMirrorStatus>;
+    }): Promise<VaultMirrorStatus>;
     /** List the vault's stored objects, diff against the mirror, fetch + hash-verify + write what's missing, in admission order. Resumable and idempotent. */
-    mirrorSync(options?: GitvaultVaultHandleOptions): Promise<GitvaultMirrorSyncSummary>;
+    mirrorSync(options?: VaultHandleOptions): Promise<VaultMirrorSyncSummary>;
     /** Keyless integrity probe against the CONFIGURED mirror: discovery + chain verification + closure/absence adjudication, never decryption (`run402 repos fsck --mirror`). */
-    mirrorVerify(options?: GitvaultVaultHandleOptions): Promise<GitvaultVerifyReport>;
+    mirrorVerify(options?: VaultHandleOptions): Promise<VaultVerifyReport>;
     /**
      * `r402s-recover` (design D4): rebuild a working git repository straight
      * from a mirrored `source/<repo_id>/` prefix — NO SERVER INVOLVED. `source`
@@ -2268,7 +2266,7 @@ export declare class Gitvault {
      * than one mirrored vault, pass `repo_id` explicitly. Recovery proves
      * validity, never freshness (both honesty statements ride every result).
      *
-     * gitvault-recovery-custody: a human member with no keystore recovers with
+     * vault-recovery-custody: a human member with no keystore recovers with
      * `member_bundle` (the exported `r402s-member-recovery-bundle/v1`, or the
      * mirror's own `member-recovery-bundles/` sidecar when omitted) +
      * `source_recovery_code`; a raw WebAuthn PRF output is NOT a supported
@@ -2279,15 +2277,15 @@ export declare class Gitvault {
         source: string;
         out_dir: string;
         repo_id?: string;
-        credential?: GitvaultMirrorCredential;
+        credential?: VaultMirrorCredential;
         region?: string;
         endpoint?: string;
-        recovery_receipt?: GitvaultRecoveryReceipt;
+        recovery_receipt?: VaultRecoveryReceipt;
         keystore_root?: string;
-        member_bundle?: GitvaultMemberRecoveryBundle;
+        member_bundle?: VaultMemberRecoveryBundle;
         source_recovery_code?: string;
         rp_id?: string;
-    }): Promise<GitvaultRecoverResult>;
+    }): Promise<VaultRecoverResult>;
     /**
      * Re-apply the local immutable-object cache's eviction window (design D3,
      * task 4.2) for one vault — a periodic backstop wired into `run402 repos
@@ -2296,7 +2294,7 @@ export declare class Gitvault {
      * only `project_id` was supplied. Idempotent and safe to call on a repo
      * with no cache directory at all (a no-op).
      */
-    sweepObjectCache(options: GitvaultVaultHandleOptions): Promise<void>;
+    sweepObjectCache(options: VaultHandleOptions): Promise<void>;
 }
 /**
  * The composite escalation trigger (design D7): ANY of these crossing its
@@ -2305,19 +2303,19 @@ export declare class Gitvault {
  * (an agent that pads one dimension to stay under a lone threshold). Shipped
  * as defaults; tunable in this ONE place, not a protocol contract.
  */
-export declare const GITVAULT_LOSS_WARNING_THRESHOLDS: {
+export declare const VAULT_LOSS_WARNING_THRESHOLDS: {
     readonly generations: 10;
     readonly source_bytes: number;
     readonly days_since_genesis: 14;
 };
 /**
- * gitvault-clone-scaling (bench P3): generations-since-checkpoint at or
+ * vault-clone-scaling (bench P3): generations-since-checkpoint at or
  * above this advises `run402 repos gc`. Same one-place-to-tune convention
- * as {@link GITVAULT_LOSS_WARNING_THRESHOLDS}; an advisory, never a gate.
+ * as {@link VAULT_LOSS_WARNING_THRESHOLDS}; an advisory, never a gate.
  */
-export declare const GITVAULT_CHECKPOINT_ADVISORY_GENERATIONS = 25;
-/** {@link gitvaultCheckpointStaleness}'s result. */
-export interface GitvaultCheckpointStaleness {
+export declare const VAULT_CHECKPOINT_ADVISORY_GENERATIONS = 25;
+/** {@link vaultCheckpointStaleness}'s result. */
+export interface VaultCheckpointStaleness {
     generations_since_checkpoint: number;
     advised: boolean;
 }
@@ -2330,12 +2328,12 @@ export interface GitvaultCheckpointStaleness {
  * `checkpoint_covers_through` doc), which is deliberately indistinguishable
  * from fresh here.
  */
-export declare function gitvaultCheckpointStaleness(input: {
+export declare function vaultCheckpointStaleness(input: {
     newest_generation: string;
     covers_through_generation: string | null;
-}): GitvaultCheckpointStaleness;
+}): VaultCheckpointStaleness;
 /** Which composite metric(s) crossed their D7 threshold, if any. */
-export interface GitvaultLossWarningTrip {
+export interface VaultLossWarningTrip {
     generations: boolean;
     source_bytes: boolean;
     days_since_genesis: boolean;
@@ -2354,13 +2352,13 @@ export interface GitvaultLossWarningTrip {
  * it, ever, in V0. What DOES now exist, one call site up in `status()`, is a
  * way to downgrade the COPY once tripped: a locally-provable read of the
  * vault's covering-recipient count (the same envelope-recipients read
- * `Gitvault.access` uses) can show this is no longer the single-principal
+ * `Repos.access` uses) can show this is no longer the single-principal
  * case the message below describes. See
- * {@link gitvaultKeystoreBackupReminderMessage} for that downgraded form.
+ * {@link vaultKeystoreBackupReminderMessage} for that downgraded form.
  */
-export declare function gitvaultLossWarningTrip(record: Pick<GitvaultVaultRecord, "admitted_generations" | "storage" | "genesis_admitted_at">, now?: Date): GitvaultLossWarningTrip;
+export declare function vaultLossWarningTrip(record: Pick<VaultRecord, "admitted_generations" | "storage" | "genesis_admitted_at">, now?: Date): VaultLossWarningTrip;
 /** Any composite metric tripped — the standing warning threshold itself. */
-export declare function gitvaultLossWarningTripped(trip: GitvaultLossWarningTrip): boolean;
+export declare function vaultLossWarningTripped(trip: VaultLossWarningTrip): boolean;
 /**
  * The standing warning text (design D7): names what tripped, states the
  * resolution honestly (a second principal or human envelope — nothing this
@@ -2369,24 +2367,24 @@ export declare function gitvaultLossWarningTripped(trip: GitvaultLossWarningTrip
  * This is the SINGLE-PRINCIPAL form — use it only when the vault's
  * covering-recipient count is unknown or <= 1. Once a caller has locally
  * proven >= 2 covering recipients, its premise ("only one principal can open
- * it") is false; use {@link gitvaultKeystoreBackupReminderMessage} instead.
+ * it") is false; use {@link vaultKeystoreBackupReminderMessage} instead.
  */
-export declare function gitvaultLossWarningMessage(trip: GitvaultLossWarningTrip): string;
+export declare function vaultLossWarningMessage(trip: VaultLossWarningTrip): string;
 /**
  * D7's downgraded form (dogfood item 2): once `status()` has locally proven
  * this vault carries >= 2 covering recipients (via the same envelope-recipients
- * read `Gitvault.access` uses), the single-principal premise behind
- * {@link gitvaultLossWarningMessage} is false for THIS vault — printing it
+ * read `Repos.access` uses), the single-principal premise behind
+ * {@link vaultLossWarningMessage} is false for THIS vault — printing it
  * anyway would be a false terminal-loss claim. The composite threshold still
- * fires the SAME way (this function does not touch `gitvaultLossWarningTrip`/
- * `gitvaultLossWarningTripped` at all — a real value-at-risk signal is still
+ * fires the SAME way (this function does not touch `vaultLossWarningTrip`/
+ * `vaultLossWarningTripped` at all — a real value-at-risk signal is still
  * worth a reminder), but the copy switches to the protocol's own
  * keystore-qualified durability sentence instead of asserting single-principal
  * risk, and never claims terminal loss.
  */
-export declare function gitvaultKeystoreBackupReminderMessage(trip: GitvaultLossWarningTrip, coveringRecipients: number): string;
+export declare function vaultKeystoreBackupReminderMessage(trip: VaultLossWarningTrip, coveringRecipients: number): string;
 /**
- * gitvault-mirror-default — the pure `vault_unmirrored` computation, in ONE
+ * vault-mirror-default — the pure `vault_unmirrored` computation, in ONE
  * place so doctor and `repos view` echo the same finding instead of each
  * deriving their own (the loss-warning pattern above). Present when no mirror
  * is configured, OR when one is configured but has no success evidence yet —
@@ -2396,58 +2394,47 @@ export declare function gitvaultKeystoreBackupReminderMessage(trip: GitvaultLoss
  * never blocking; every input is client-local or read from the CUSTOMER'S
  * mirror — nothing here touches the gateway.
  */
-export declare function gitvaultUnmirroredFinding(state: {
+export declare function vaultUnmirroredFinding(state: {
     configured: boolean;
     last_success_at: string | null;
     mirrored_generation: string | null;
-    /** gitvault-byo-primary-bucket task 3.5 — when true, `message` uses the BYO remedy wording (a SECOND customer-held location) instead of the plain unmirrored statement. */
+    /** vault-byo-primary-bucket task 3.5 — when true, `message` uses the BYO remedy wording (a SECOND customer-held location) instead of the plain unmirrored statement. */
     is_byo?: boolean;
-}): GitvaultUnmirroredFinding | null;
+}): VaultUnmirroredFinding | null;
 /**
- * gitvault-byo-primary-bucket (design D4) — the ONE stderr line a degraded
+ * vault-byo-primary-bucket (design D4) — the ONE stderr line a degraded
  * chain/payload read prints: the fallback's own destination (never a
  * credential) plus the canonical, mechanism-only statement. `list`/`fetch`
  * degrading in the SAME `git-remote-run402` session each print their own
  * line (one per degraded READ, not one per session) — see
- * `Gitvault.withDegradedRead`'s own doc comment.
+ * `Repos.withDegradedRead`'s own doc comment.
  */
-export declare function gitvaultDegradedReadNote(source: GitvaultDegradedReadSource): string;
+export declare function vaultDegradedReadNote(source: VaultDegradedReadSource): string;
+/** `run402::<org_id>/<project_id>` — what `git-remote-run402` resolves. */
+export declare function vaultRemoteUrl(orgId: string, projectId: string): string;
 /**
- * The remote door (kygit-handoff design D8): `"run402"` (the canonical,
- * plumbing spelling — accepted forever) or `"kygit"` (what the
- * `@kychee/kygit` shim renders once it sets `RUN402_REMOTE_SCHEME=kygit`
- * before exec). The gateway never sees this — `address` and every registry
- * `next_actions` command stay `run402::`; only client-side RENDERING reads
- * it. Any other value falls back to `"run402"` rather than emitting an
- * unparseable scheme.
- */
-export declare function gitvaultRemoteScheme(): "run402" | "kygit";
-/** `<door>::<org_id>/<project_id>` — what `git-remote-run402`/`git-remote-kygit` resolves. */
-export declare function gitvaultRemoteUrl(orgId: string, projectId: string): string;
-/**
- * `<door>::<org-slug>/<repo-name>` — the address-form remote builder
+ * `run402::<org-slug>/<repo-name>` — the address-form remote builder
  * (repo-first-onramp task 4, design D6). Same string shape as
- * {@link gitvaultRemoteUrl} (the wire slot admits both forms undiscriminated
- * — see {@link gitvaultRemoteAddressForm}); kept as its own named function so
+ * {@link vaultRemoteUrl} (the wire slot admits both forms undiscriminated
+ * — see {@link vaultRemoteAddressForm}); kept as its own named function so
  * a call site states which form it means rather than reusing the id-form
- * builder for a semantically different pair of arguments. Rendered by
- * {@link gitvaultRemoteScheme} (kygit-handoff design D8) — `run402 repos
- * create` renders `run402::`, `kygit create` renders `kygit::`.
+ * builder for a semantically different pair of arguments.
  */
-export declare function gitvaultRemoteUrlForRepo(orgSlug: string, repoName: string): string;
-/** What {@link parseGitvaultRemoteUrl} returns — the two undiscriminated address halves. */
-export interface GitvaultRemoteAddress {
+export declare function vaultRemoteUrlForRepo(orgSlug: string, repoName: string): string;
+/** What {@link parseVaultRemoteUrl} returns — the two undiscriminated address halves. */
+export interface VaultRemoteAddress {
     org_id: string;
     project_id: string;
 }
 /**
- * Parse a `run402::<org>/<project>` OR `kygit::<org>/<project>` remote URL
- * (kygit-handoff design D8) into ONE canonical, scheme-less address — the
- * door never changes resolution, only rendering. `null` when it is neither.
+ * Parse a `run402::<org>/<project>` remote URL into its two address halves.
+ * `run402::` is the one remote scheme: `null` for anything that is not a
+ * `<scheme>::` address at all, and a typed `REMOTE_SCHEME_UNSUPPORTED`
+ * refusal naming the scheme for any other `<scheme>::` spelling.
  */
-export declare function parseGitvaultRemoteUrl(url: string): GitvaultRemoteAddress | null;
+export declare function parseVaultRemoteUrl(url: string): VaultRemoteAddress | null;
 /** Which address form a parsed `run402::` remote is (repo-first-onramp task 4, design D6). */
-export type GitvaultRemoteAddressForm = "id" | "slug";
+export type VaultRemoteAddressForm = "id" | "slug";
 /**
  * Discriminate a parsed address's form (design D6, "resolved"): "org UUIDs
  * and `prj_` prefixes make slug-vs-id in the same slot unambiguous." Both
@@ -2457,9 +2444,9 @@ export type GitvaultRemoteAddressForm = "id" | "slug";
  * `prj_`-prefixed; anything else (an org slug half, or a bare repo-name half)
  * is slug-form. Resolution accepts either (task 4.3).
  */
-export declare function gitvaultRemoteAddressForm(address: GitvaultRemoteAddress): GitvaultRemoteAddressForm;
+export declare function vaultRemoteAddressForm(address: VaultRemoteAddress): VaultRemoteAddressForm;
 /** What a `SLUG_RELEASED` refusal names — the successor slug and the cooldown window (design D6). */
-export interface GitvaultSlugReleasedInfo {
+export interface VaultSlugReleasedInfo {
     successor_slug: string | null;
     released_at: string | null;
     cooldown_until: string | null;
@@ -2470,5 +2457,5 @@ export interface GitvaultSlugReleasedInfo {
  * (design D6: "no redirects, deliberately"). `null` when `err` is not a
  * `SLUG_RELEASED` refusal.
  */
-export declare function gitvaultSlugReleasedInfo(err: unknown): GitvaultSlugReleasedInfo | null;
-//# sourceMappingURL=gitvault.d.ts.map
+export declare function vaultSlugReleasedInfo(err: unknown): VaultSlugReleasedInfo | null;
+//# sourceMappingURL=repos.d.ts.map