Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
feat(vaults): support multi-field secrets and record delivery (#2563)
Call White20664d45bbe2
diff --git a/docs/plans/2026-10-13-vault-multi-field-secrets.md b/docs/plans/2026-10-13-vault-multi-field-secrets.mdnew file mode 100644index 000000000..3b0a807a2--- /dev/null+++ b/docs/plans/2026-10-13-vault-multi-field-secrets.md@@ -0,0 +1,296 @@+# Vault multi-field secrets++Status: P1 contract. The owner approved the direction and the four decisions in+section 2 on 2026-10-13.++Related: `vaults-grant-delivery-refactor.md` (current grant and delivery model),+`avault-custody-core.md`, `vault-sandbox-protocol-v2.md`, and+`../avault/docs/DESIGN.md` (authoritative envelope and AAD design).++## 1. Background++A user asked for one Vault entry to hold several secret values, like a+1Password item: a login has a username, a password, and a 2FA secret. Today a+Vault secret holds exactly one value, so a login becomes three unrelated+secrets.++## 2. Goal and decisions++One secret can hold several named fields. Agents reference a field as+`NAME.field`. Values still never enter the model context, and avault's+cryptography and wire formats do not change.++Approved decisions:++1. A secret has one **default field** (its existing value) plus optional+ **extra fields**.+2. Authorization stays per secret. Approving a protected secret releases the+ DEKs of all its fields, and grants still list secret names.+3. `--tag` and `--skill` deliver every field of each selected secret. `--env`+ still maps exactly one value to one variable.+4. P1 can replace the value of any field, including the default field.++Built-in 2FA code generation is P2 (section 13).++## 3. Names and records (shared contract)++| Term | Grammar |+| --- | --- |+| Secret name (unchanged) | `^[A-Za-z_][A-Za-z0-9_]*$` |+| Field name | `^[a-z][a-z0-9_]{0,63}$` |+| Record name | `^[A-Za-z_][A-Za-z0-9_]*(\.[a-z][a-z0-9_]{0,63})?$` |++- A **record** is one encrypted value. The default field's record name is the+ bare secret name (`GITHUB_LOGIN`), whatever the default field is called. An+ extra field's record name is `<secret>.<field>` (`GITHUB_LOGIN.username`).+ `<secret>.<default field name>` is never a record name.+- A **ref** is what users and agents write: `NAME` or `NAME.field`. Both `NAME`+ and `NAME.<default field name>` resolve to the default record.+- Existing secrets have a default field named `value` and no extra fields.+- Field names are unique within a secret, including the default field's name.+ A secret has at most 32 fields, counting the default field.+- Extra field names are immutable because their ciphertext binds the record+ name. To rename one, remove it and add it again. The default field's name is+ only a label and can be renamed. Which field is the default is fixed when the+ secret is created.+- Only `static` secrets can have extra fields. Keypair secrets keep one implicit+ `value` field: create/PATCH reject an explicit `default_field`, and refs such+ as `KEY.field` are rejected.++Every envelope binds its record name:++- Standard tier: avault seals and opens with AAD+ `record || "machine-aesgcm-v1" || 0x01`.+- Protected tier: the protected-record v2 AAD JSON carries+ `"name": "<record>"` and `"record": {"kind": "static"}`.+- Blind boxes: the `name` AAD field is the record name for `seal` and+ `agent-deliver`, and the agent-deliver `operation_hash` covers the record+ name.++avault already treats this name as an opaque string. A probe with avault 0.1.6+and a temporary file store delivered `GH.username` and `GH` to one child process,+and rejected a `GH.username` envelope presented as `GH.password` or `GH`. The+vault-sandbox crypto validator still accepts only secret names, so it must+accept record names before protected secrets can have extra fields.++## 4. Storage++- New nullable TEXT column `vault_secrets.fields`. It holds a JSON array of the+ extra fields in display order:++ ```json+ [{"name": "username", "ciphertext": "...", "nonce": "...", "wrap_meta": "...",+ "created_at": "...", "updated_at": "..."}]+ ```++ NULL or `[]` means no extra fields.+- The default field keeps the existing `ciphertext`, `nonce`, and `wrap_meta`+ columns unchanged.+- The default field's name is `public_meta.default_field`. When it is absent+ or invalid, the name is `value`.+- All fields share the secret's `kind`, `protection`, tags, policy, resource+ access policy, and audit history.+- Every envelope change bumps `vault_secrets.updated_at`, so stale approval+ material is detected through the existing member versions. Field writes are+ atomic per secret: a concurrent change fails as a conflict, never as a lost+ update.+- The migration adds the column and its downgrade drops it. Released versions+ ignore the column and keep reading the default value. The `vibe data query`+ denylist already covers `vault_secrets`.++## 5. Value-free metadata++The secret metadata payload (`_meta_payload`, REST, and `vibe vault list/find+--json`) adds two keys:++- `default_field`: the default field's name.+- `fields`: every field name, default field first, then extra fields in stored+ order. An existing secret shows `"default_field": "value", "fields": ["value"]`.++- A corrupt extra-field section adds `"fields_state": "corrupt"` to this+ value-free metadata, while `fields` exposes only the available default. Web+ rows/editors warn about the corruption, and tag/skill expansion refuses to+ deliver a partial field set.++## 6. Delivery++| Selector | Records | Environment variable |+| --- | --- | --- |+| `--env NAME` | default record | `NAME` |+| `--env NAME.field` | that field's record | `NAME_<FIELD>` |+| `--env LOCAL=NAME[.field]` | the referenced record | `LOCAL` |+| `--tag T`, `--skill S` | every record of each selected static secret | default record as `NAME`; each extra field as `NAME_<FIELD>` |++- `<FIELD>` is the field name in upper case: `GITHUB_LOGIN.username` becomes+ `GITHUB_LOGIN_USERNAME`. The rule also applies when the ref names the default+ field: `GITHUB_LOGIN.password` becomes `GITHUB_LOGIN_PASSWORD` and delivers+ the record `GITHUB_LOGIN`.+- Conflicts fail before delivery, as today but per record: one record selected+ under two variable names, or one variable name mapped to two records.+- An unknown field fails with a `field_not_found` error that lists the secret's+ fields. Keypair rejection (`keypair_not_value_deliverable`) is unchanged.+- `vibe vault fetch --auth NAME[.field]` attaches that record. The allowed+ hosts and auth scheme come from the secret's policy.+- `vibe vault inject` accepts the same selectors as `run`, including field refs.+ Avibe always sends an explicit `key`, because avault's fallback key would be+ the record name, which is not a valid key.+- `vibe vault export` stays deprecated and returns `export_deprecated`, with no+ delivery. Its parser and help are unchanged.+- Commands that only authorize, such as `vibe vault access`, accept+ `NAME.field` and authorize the secret.+- Every avault entry carries `name` = record name, that record's `envelope`,+ and `tier` = the secret's protection.+- Completed delivery bookkeeping uses the secret/field identities captured in+ the pre-delivery plan, not a second record lookup. Removing or renaming a+ field while a child runs must not drop its audit or the rest of the batch.+- Use counts stay per secret. The delivery audit lists the delivered fields.++## 7. Authorization++- Grants, access requests, `always_ask`, and one-shot handling stay keyed by+ secret names. `member_snapshot` keeps listing secret names.+- A protected DEK release covers every record of each protected member:+ - Approval card `grant_options[].unlock_material` carries one material per+ record, named by record name.+ - The agent-binding batch issues one signed release context per record, with+ the operation hash over the record name. The signed `display.secrets` lists+ every record (`{"name": "<record>", "kind": "static"}`) because the sandbox+ requires the display block to cover each release item.+ - Grant creation requires the submitted DEK names to equal the record names+ of the protected members.+- Within a live grant, delivery may use any record of a covered secret.+- Any envelope change expires the secret's pending requests and active grants,+ and releases resident avault scopes, as rotate and delete do today.+- The approval card shows each member's field names.++## 8. API++- `POST /api/vault/secrets` accepts an optional `default_field` and optional+ `fields`: `[{"name", "record", "blind_box"}]` for standard secrets or+ `[{"name", "record", "sealed"}]` for protected secrets. The top-level `blind_box` or+ `sealed` is still the default field. For standard secrets Python seals each+ field with `avault seal --name <record> --blind-box`. Keypairs reject `fields`.+- `PUT /api/vault/secrets/{name}/fields/{field}` takes `{"record", "blind_box"}`+ or `{"record", "sealed"}`. For the default field it replaces the default envelope.+ Otherwise it adds the field (appended) or replaces its value. It returns the+ masked metadata.+- `DELETE /api/vault/secrets/{name}/fields/{field}` removes an extra field. The+ browser sends `{"expected_updated_at": "<displayed version>"}` so deleting a+ field changed in another tab returns 409 `secret_conflict`. The default field+ cannot be removed (409).+- `PATCH /api/vault/secrets/{name}` also accepts `default_field` to rename the+ default field. The name must be valid and unused; this is pure metadata and+ leaves envelope versions, pending requests, and active grants unchanged.+- `POST /api/vault/secrets/{name}/reveal-context` accepts an optional `field`+ and returns the context and envelope of that record.+- Every extra create field and field PUT declares the `record` name used to+ seal it; the server rejects a mismatch with its current field resolution as+ 409 `record_mismatch` without storing anything, and the UI re-reads metadata+ and re-seals once (the top-level create record is implicitly `NAME`).+- New error codes: `invalid_field_name`, `field_exists`, `field_not_found`,+ `too_many_fields`, `fields_not_supported`, `record_mismatch`, `fields_corrupt`.+ Corrupt extra-field storage is warned about and unavailable as a whole; the+ default record remains usable, while field mutations preserve the original+ bytes and refuse until the stored section is repaired.+- Plaintext rejection, resource-access checks, SSE updates, and audit apply to+ every new path. Field changes audit as `updated` with+ `{"field": "<name>", "op": "add" | "replace" | "remove"}`.+- The browser derives the record name (`NAME` for the default field,+ `NAME.field` otherwise) and seals with it: standard secrets use+ `standardCreateBlindBoxContext(record)`, protected secrets use the sandbox+ `seal({name: record, kind: "static"})`.++## 9. Provision requests++The request spec gains `fields` (field names in display order) and+`default_field` (one of `fields`; defaults to the first). They never carry+values.++```bash+vibe vault request GITHUB_LOGIN --reason "Log in to GitHub" \+ --spec-json '{"protection":"protected","fields":["username","password","totp"],"default_field":"password"}'+```++The browser form starts with those rows. The user may remove rows, and every+submitted field needs a value. Field-aware provision replies (asynchronous+callbacks, synchronous `--wait`, and already-existing results) list current field+labels and the default alias from the created secret, not the requested spec,+and share the same field-ref delivery hint. A user-created multi-field shape+also receives this hint when the original request had no field spec.++## 10. UI++- Create: a static secret looks the same as today until the user adds a field.+ Then the value becomes a list of field rows (name and value), with exactly one+ default. A Login template fills `username`, `password` (default), and `totp`.+ File upload stays available only for a single-value standard secret.+- A protected create seals every field in the same sandbox session and sends+ one create request. Vault establishment fields are sent once.+- Edit: replace any field's value, add or remove extra fields, and rename the+ default field. Name, kind, and protection stay read-only. After mount the+ editor owns current server metadata and drafts: own-write responses or+ sequenced authoritative refetches update truth, while changed parent props+ and Vault events trigger refetches rather than directly replacing it. Only+ the latest refetch may apply. Draft reconciliation preserves retained labels,+ moves a renamed default draft, notices removed drafts, and preserves a dirty+ label input unless its own rename succeeds.+- List and detail show field names when a secret has more than one field.+- Protected reveal works per field.+- The approval card groups records by secret and shows field names.+- Strings go through `ui/src/i18n/{en,zh}.json`; reuse the existing primitives.++## 11. Cross-repository work++| Repository | Change |+| --- | --- |+| avibe | Storage, service, API, CLI, UI, `use-avibe-vault` skill, tests |+| vault-sandbox | Accept record names in crypto-name validation, with tests |+| avault | DESIGN documents the record-name convention; vectors and tests pin field records; no code change |+| avibe-docs | Vault concept page in English and Chinese |++The sandbox change only widens accepted names, so it can deploy first. Standard+secrets with fields work without it; protected secrets with fields need it.++## 12. Validation++- Existing secrets keep their delivery behavior; their metadata adds only+ `default_field` and `fields`.+- New paths accept no plaintext.+- Fields are sealed and delivered under their record names; avault tests show+ a field envelope does not open under another record name.+- Selectors cover refs, variable naming, tag and skill expansion with extra+ fields, conflicts, unknown fields, and keypair rejection.+- Protected approval releases every record, delivery of any field works under+ the grant, and a field change expires the grant.+- The migration upgrades and downgrades with existing rows.+- The skill's CLI examples parse.++## 13. Out of scope for P1++- **2FA codes (P2).** A `totp` field type. avault computes the current code at+ delivery, so the child gets the code and never the seed, and sandbox reveal+ shows a live code. This needs avault (HMAC-SHA1/256/512, base32, `otpauth://`+ parsing) with a DESIGN update, the sandbox, and Python type metadata. Until+ then a 2FA secret can be stored as an ordinary field.+- HTTP Basic auth in `fetch` from a username and password field.+- 1Password import that maps item fields to Vault fields.++## 14. Known by design++- Approving a protected secret unlocks all its fields for the grant's lifetime.+- Extra field names and the choice of default field cannot change after+ creation.+- Standard values stay hidden in the UI.+- The CLI cannot write fields; values enter only through the browser.+- `export` remains deprecated and never delivers values. Agent-initiated field+ deletion is out of scope; browser/REST removal of extra fields is supported.+- There are no plaintext or non-secret fields; non-secret notes belong in the+ description.+- Web field errors are localized from the canonical stable-code tuple in+ `vibe/api.py`, guarded against both catalogs; agent-facing CLI/service+ diagnostic text stays English.+- VMK-copy discovery (`latest_protected_vmk_wrap_meta`) selects the default+ envelope on the most recently updated secret. Updating an extra field can+ move a secret with older VMK copies to the front. This is latent while the+ sandbox writes the base VMK wrap only at setup; multi-passkey/VMK-copy changes+ must replace this selection before allowing those copies to diverge.diff --git a/skills/use-avibe-vault/SKILL.md b/skills/use-avibe-vault/SKILL.mdindex 7e0b07b24..15a59ca83 100644--- a/skills/use-avibe-vault/SKILL.md+++ b/skills/use-avibe-vault/SKILL.md@@ -2,7 +2,7 @@name: use-avibe-vaultslug: use-avibe-vaultdescription: Use Avibe Vault for API keys, tokens, passwords, protected credentials, authenticated HTTP requests, or digest signing without exposing secret values to the agent.-version: 0.2.0+version: 0.3.0---# Use Avibe Vault@@ -11,13 +11,18 @@ When a task needs API keys, access tokens, passwords, wallet private keys, or otCore concepts:- Static secret: a regular secret value, such as an API key, token, database password, or deployment credential. Use it with `vibe vault run` for environment injection or `vibe vault fetch` for authenticated HTTP egress.+- A static secret can contain up to 32 named fields. `NAME` selects its default field (existing secrets call it `value`); `NAME.field` selects that field, including an explicit default label such as `GITHUB_LOGIN.password`. Field names match `^[a-z][a-z0-9_]{0,63}$`. The default label may be renamed; extra labels and the choice of default cannot change after creation.- Keypair secret: a signing key for digests or transactions, such as a wallet key or deployment signer. It cannot be exported as an environment variable and cannot be used with `run` / `fetch`; use `vibe vault sign`.- Standard: for lower-risk routine automation. Agents can usually use it without interrupting the user unless it is configured to ask first.- Protected: for high-risk secrets, such as production databases or wallet/funds keys. Because protected secrets are end-to-end encrypted, use requires browser approval and passkey unlock.Rules:-- Refer to secrets only by secret name, tag, or skill tag.-- Static secrets can be used with `run` / `fetch`; keypair secrets can only be used with `vibe vault sign`.+- Refer to secrets only by secret name, record ref (`NAME.field`), tag, or skill tag.+- Static secrets can be used with `run` / `fetch`; keypair secrets can only be used with `vibe vault sign`. Keypairs do not accept field refs.+- Authorization is per secret: approving a protected secret unlocks **all its fields** for the grant's lifetime. The CLI cannot create, replace, or delete fields; the user does that in the browser.+- `--env NAME.field` delivers one value to `NAME_FIELD` (only the field is uppercased); `--env LOCAL=NAME.field` chooses the variable. `--tag` and `--skill` deliver every field of each selected secret, using `NAME` for the default and `NAME_FIELD` for extras. Conflicting variable mappings fail before delivery.+- `list` and `find` return value-free `default_field` and `fields` metadata. If a ref fails with `field_not_found`, use the listed field names rather than guessing.+- `export` remains deprecated and has no delivery. Prefer `run`; advanced `inject` writes a restricted-permission file, so use it only for tools that require file-based configuration.- With `vibe vault run`, the child process receives static secrets as environment variables, so never run commands that may print env vars, debug config, or secret-bearing errors.- When protected `run` / `fetch` needs approval, Avibe automatically asks the user to decrypt and authorize access. After the user approves, Avibe resumes this session; it does not replay the command for you, so run the same `run` / `fetch` command again.- When protected `sign` needs approval, Avibe creates a browser signing request and returns immediately. Do not rerun `sign`; when Avibe resumes this session, follow the callback instruction to read the completed request result and continue with the returned signature.@@ -27,6 +32,11 @@ Common commands:Request that the user add a missing static secret. `spec-json` may contain only non-secret prefill metadata; the actual secret value is entered by the user in the browser:`vibe vault request OPENAI_API_KEY --reason "Need OpenAI API access" --spec-json '{"kind":"static","protection":"protected","description":"OpenAI API key","tags":["openai","prod","skill:model-work"],"policy":{"allowed_hosts":["api.openai.com"],"auth":{"type":"bearer"}}}'`+Request a multi-field login item with a password default. These are field names only, never values:+`vibe vault request GITHUB_LOGIN --reason "Log in to GitHub" --spec-json '{"protection":"protected","fields":["username","password","totp"],"default_field":"password"}'`++A `totp` field is ordinary stored secret material in this version, not a generated one-time code.+For a missing keypair/signing key, ask the user to create a keypair secret in the Vault UI; do not request or store private-key material as a static secret.On Avibe Web chat, a lighter manual prompt can mention the missing secret as a clickable placeholder in your reply, for example `$<OPENAI_API_KEY>`. The user can click it and fill the secret from Web chat. This has no reason or structured prefill metadata; use `vibe vault request` when those are needed.@@ -40,19 +50,26 @@ List or find existing Vault entries:Run a command with selected static secrets injected as environment variables:`vibe vault run --env OPENAI_API_KEY,GITHUB_TOKEN -- python script.py`-`vibe vault run --env GITHUB_TOKEN=GH_PAT --env OPENAI_API_KEY -- python script.py`+`vibe vault run --env GITHUB_LOGIN.username -- python script.py`+`vibe vault run --env PASSWORD=GITHUB_LOGIN.password -- python script.py``vibe vault run --tag deploy -- ./deploy.sh``vibe vault run --skill github-release -- ./release.sh`Make an authenticated HTTP request. The credential is attached only at egress, and the agent never sees the secret:-`vibe vault fetch --auth GITHUB_PAT --url https://api.github.com/user`+`vibe vault fetch --auth GITHUB_API.token --url https://api.github.com/user`++The secret's allowed hosts and auth scheme apply to every field; this attaches one field, not a username/password pair.++For tools that require a file, `inject` uses the same selectors and explicit output keys:+`vibe vault inject --env USERNAME=GITHUB_LOGIN.username --env PASSWORD=GITHUB_LOGIN.password --out login.env --format dotenv`+`vibe vault inject --tag deploy --out deploy.json --format json`Request approval before a protected `run` with an existing static secret:-`vibe vault access PROD_DB_URL --skill deploy --command "run database migration" --egress "connect to production database"`+`vibe vault access GITHUB_LOGIN.password --skill deploy --command "Log in to GitHub" --egress "github.com"`For protected `fetch`, run `vibe vault fetch`; it creates the correct fetch approval request when needed.Sign a 32-byte digest with a keypair secret. Standard keys may return the signature directly; protected keys create a browser approval request:-`vibe vault sign WALLET_KEY --digest <64-hex-digest> --scheme ecdsa-secp256k1-recoverable --command "sign deployment transaction"`+`vibe vault sign WALLET_KEY --digest 0000000000000000000000000000000000000000000000000000000000000001 --scheme ecdsa-secp256k1-recoverable --command "sign deployment transaction"`For more details, run `vibe vault --help`.diff --git a/storage/alembic/versions/20261013_0065_vault_secret_fields.py b/storage/alembic/versions/20261013_0065_vault_secret_fields.pynew file mode 100644index 000000000..9f8d9b777--- /dev/null+++ b/storage/alembic/versions/20261013_0065_vault_secret_fields.py@@ -0,0 +1,39 @@+"""Add named extra fields to Vault secrets.++Revision ID: 20261013_0065+Revises: 20261012_0064+"""++from __future__ import annotations++import sqlalchemy as sa+from alembic import op++revision = "20261013_0065"+down_revision = "20261012_0064"+branch_labels = None+depends_on = None+MIGRATION_SAFETY = "additive"+++def _columns() -> set[str]:+ bind = op.get_bind()+ return {str(row[1]) for row in bind.exec_driver_sql("pragma table_info(vault_secrets)")}+++def upgrade() -> None:+ if "fields" not in _columns():+ op.add_column("vault_secrets", sa.Column("fields", sa.Text(), nullable=True))+++def downgrade() -> None:+ if "fields" in _columns():+ # SQLite before 3.35 cannot DROP COLUMN. Batch rebuilding also preserves+ # the ordinary name constraint/index, but reflection skips expression+ # indexes, so restore the folded-name uniqueness guard explicitly.+ with op.batch_alter_table("vault_secrets") as batch:+ batch.drop_column("fields")+ op.get_bind().exec_driver_sql(+ "create unique index if not exists uq_vault_secrets_name_folded "+ "on vault_secrets (lower(name))"+ )diff --git a/storage/migrations.py b/storage/migrations.pyindex c3d26e18e..b52ce6a4d 100644--- a/storage/migrations.py+++ b/storage/migrations.py@@ -158,6 +158,7 @@ HEAD_REQUIRED_COLUMNS = PRE_SHOW_SESSION_EVENTS_REQUIRED_COLUMNS | {},}HEAD_ONLY_REQUIRED_COLUMNS = {+ "vault_secrets": {"fields"},"show_pages": {"access_mode", "access_revision", "share_id", "offline_at"},"show_page_access_entries": {"page_id",@@ -710,6 +711,9 @@ def _repair_head_required_columns(conn: sqlite3.Connection, tables: set[str]) ->if table in tables and "context_seq" not in _column_names(conn, table):conn.execute(f'alter table "{table}" add column "context_seq" INTEGER')changed = True+ if "vault_secrets" in tables and "fields" not in _column_names(conn, "vault_secrets"):+ conn.execute('alter table "vault_secrets" add column "fields" TEXT')+ changed = True_ensure_head_indexes(conn, tables)return changeddiff --git a/storage/models.py b/storage/models.pyindex 4d122bad5..5e25a4181 100644--- a/storage/models.py+++ b/storage/models.py@@ -1260,6 +1260,9 @@ vault_secrets = Table(Column("ciphertext", Text, nullable=True),Column("nonce", Text, nullable=True),Column("wrap_meta", Text, nullable=True),+ # JSON array of extra named field envelopes. The default field remains in the+ # legacy ciphertext/nonce/wrap_meta columns for released-version compatibility.+ Column("fields", Text, nullable=True),Column("public_meta", Text, nullable=True), # JSON: desc / pubkey / address / op:// uriColumn("policy", Text, nullable=True), # JSON: allowed modes, allowed hosts, always_askColumn("last_used_at", String, nullable=True),diff --git a/storage/vault_service.py b/storage/vault_service.pyindex 63c51200e..c716e8f48 100644--- a/storage/vault_service.py+++ b/storage/vault_service.py@@ -22,6 +22,7 @@ import threadingimport uuidfrom dataclasses import dataclassfrom datetime import datetime, timedelta, timezone+from functools import lru_cachefrom typing import Anyfrom urllib.parse import urlsplit@@ -91,7 +92,11 @@ PROVISION_SPEC_ALLOWED_KEYS = {"tags","policy","links",+ "fields",+ "default_field",}+PROVISION_FIELD_NAME_RE = re.compile(r"^[a-z][a-z0-9_]{0,63}$")+MAX_SECRET_FIELDS = 32PROVISION_SPEC_ALLOWED_POLICY_KEYS = {"allowed_hosts", "auth"}PROVISION_SPEC_ALLOWED_AUTH_KEYS = {"type", "name"}FETCH_AUTH_HEADER_NAME_RE = re.compile(r"^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$")@@ -100,6 +105,16 @@ FORBIDDEN_FETCH_AUTH_HEADER_NAMES = frozenset({"host"})_UNSET = object()+@dataclass(frozen=True)+class DeliveryIdentity:+ """Value-free pre-handoff identity retained for post-delivery bookkeeping."""++ secret_id: str+ name: str+ field: str+ access_snapshot: dict[str, Any] | None++@dataclass(frozen=True)class GrantApproval:grant_id: str@@ -149,6 +164,38 @@ class SecretExistsError(VaultServiceError):pass+class InvalidFieldNameError(VaultServiceError):+ pass+++class FieldExistsError(VaultServiceError):+ pass+++class FieldNotFoundError(VaultServiceError):+ pass+++class TooManyFieldsError(VaultServiceError):+ pass+++class FieldsNotSupportedError(VaultServiceError):+ pass+++class FieldsCorruptError(VaultServiceError):+ pass+++class RecordMismatchError(VaultServiceError):+ pass+++class SecretConflictError(VaultServiceError):+ pass++class SecretNameCaseConflictError(VaultServiceError):def __init__(self, name: str, existing_name: str):self.name = name@@ -309,6 +356,14 @@ def _parse_iso_datetime(value: str | None) -> datetime | None:return parsed.astimezone(timezone.utc)+def _next_updated_at(previous: str | None = None) -> str:+ current = datetime.now(timezone.utc)+ previous_dt = _parse_iso_datetime(previous)+ if previous_dt is not None and current <= previous_dt:+ current = previous_dt + timedelta(microseconds=1)+ return current.isoformat()++def _id(prefix: str) -> str:return f"{prefix}_{uuid.uuid4().hex[:12]}"@@ -511,6 +566,148 @@ def _public_meta(raw: str | None) -> dict[str, Any]:return payload if isinstance(payload, dict) else {}+def _validate_field_name(name: Any, *, field: str = "field") -> str:+ if not isinstance(name, str) or not PROVISION_FIELD_NAME_RE.fullmatch(name):+ raise InvalidFieldNameError(f"{field} must match ^[a-z][a-z0-9_]{{0,63}}$")+ return name+++def _default_field_name(row: dict[str, Any] | None = None, value: Any = None) -> str:+ if row is not None and row.get("kind") == "keypair":+ return "value"+ candidate = value+ if candidate is None and row is not None:+ candidate = _public_meta(row.get("public_meta")).get("default_field")+ try:+ return _validate_field_name(candidate or "value", field="default_field")+ except InvalidFieldNameError:+ return "value"+++@lru_cache(maxsize=512)+def _warn_corrupt_fields(name: str, secret_id: str, updated_at: str) -> None:+ """Bounded warning cache: repeated reads of one damaged revision stay quiet."""+ logger.warning("Vault secret %s has corrupt fields; extra records and field mutations are unavailable", name)+++def _extra_field_rows(row: dict[str, Any] | None, *, strict: bool = False) -> list[dict[str, Any]]:+ """Read the complete optional section, never a lossy partial projection.++ Default-record reads remain available when extras are corrupt. Any caller+ that writes fields or needs an extra record must fail closed instead.+ """+ if not row or row.get("fields") is None:+ return []+ try:+ raw = json.loads(row["fields"])+ if not isinstance(raw, list) or len(raw) >= MAX_SECRET_FIELDS:+ raise ValueError("invalid field array")+ seen = {_default_field_name(row)}+ if row.get("kind") == "keypair" and raw:+ raise ValueError("keypair has extra fields")+ for item in raw:+ if not isinstance(item, dict):+ raise ValueError("invalid field entry")+ name = _validate_field_name(item.get("name"))+ if name in seen:+ raise ValueError("duplicate field label")+ if not all(isinstance(item.get(key), str) and item[key] for key in ("ciphertext", "nonce", "wrap_meta", "created_at", "updated_at")):+ raise ValueError("incomplete field envelope")+ seen.add(name)+ return [dict(item) for item in raw]+ except (TypeError, ValueError, InvalidFieldNameError):+ # Neither malformed serialized values nor exception details are safe to log.+ _warn_corrupt_fields(str(row.get("name") or ""), str(row.get("id") or ""), str(row.get("updated_at") or ""))+ if strict:+ raise FieldsCorruptError(f"secret {row.get('name')!r} has corrupt fields; existing data was preserved") from None+ return []+++def secret_field_names(row: dict[str, Any]) -> list[str]:+ return [_default_field_name(row), *[str(item["name"]) for item in _extra_field_rows(row, strict=False)]]+++def record_name_for_field(secret_name: str, field_name: str, *, default_field: str = "value") -> str:+ return secret_name if field_name == default_field else f"{secret_name}.{field_name}"+++def _record_entries(row: dict[str, Any], *, strict: bool = False) -> list[dict[str, Any]]:+ default_field = _default_field_name(row)+ entries = [+ {+ "name": row["name"],+ "field": default_field,+ "envelope": _row_sealed(row),+ "kind": row.get("kind"),+ "protection": row.get("protection"),+ }+ ]+ for field in _extra_field_rows(row, strict=strict):+ entries.append(+ {+ "name": record_name_for_field(str(row["name"]), str(field["name"]), default_field=default_field),+ "field": str(field["name"]),+ "envelope": Sealed(+ ciphertext=field["ciphertext"], nonce=field["nonce"], wrap_meta=field["wrap_meta"]+ ),+ "kind": row.get("kind"),+ "protection": row.get("protection"),+ }+ )+ return entries+++def _resolve_record_ref(conn: Connection, ref: str, *, user_context: Any = None) -> tuple[dict[str, Any], dict[str, Any]]:+ raw = str(ref or "").strip()+ parts = raw.split(".", 1)+ secret_name = parts[0]+ if not vault_crypto.is_valid_secret_name(secret_name):+ raise InvalidSecretNameError(secret_name)+ row = require_secret_access(conn, secret_name, user_context=user_context)+ field_ref = parts[1] if len(parts) == 2 else None+ default_field = _default_field_name(row)+ if field_ref is not None and row.get("kind") == "keypair":+ raise FieldsNotSupportedError(f"{secret_name} does not support fields")+ if field_ref is None or field_ref == default_field:+ field_name = default_field+ else:+ _validate_field_name(field_ref)+ if field_ref not in {str(item["name"]) for item in _extra_field_rows(row, strict=True)}:+ raise FieldNotFoundError(f"field {field_ref!r} not found on {secret_name}; fields: {', '.join(secret_field_names(row))}")+ field_name = field_ref+ entry = next(item for item in _record_entries(row) if item["field"] == field_name)+ return row, entry+++def validate_field_name(value: Any, *, field: str = "field") -> str:+ return _validate_field_name(value, field=field)+++def secret_record_names(secret: dict[str, Any]) -> list[str]:+ name = str(secret.get("name") or "")+ default_field = str(secret.get("default_field") or _default_field_name(secret))+ raw_fields = secret.get("fields")+ fields = raw_fields if isinstance(raw_fields, list) else [default_field]+ result = [name]+ for raw_field in fields:+ field = str(raw_field)+ if field != default_field:+ result.append(f"{name}.{field}")+ return result+++def get_secret_record_meta(conn: Connection, ref: str, *, user_context: Any = None) -> dict[str, Any]:+ row, entry = _resolve_record_ref(conn, ref, user_context=user_context)+ payload = _meta_payload(row)+ payload["record_name"] = str(entry["name"])+ payload["field"] = str(entry["field"])+ return payload+++def require_secret_management(conn: Connection, name: str, *, user_context: Any = None) -> dict[str, Any]:+ return _require_secret_resource_management(conn, _require_row(conn, name), resolve_resource_access_context(user_context))++def _reject_provision_spec_secret_fields(value: Any, *, path: str = "spec") -> None:if isinstance(value, dict):for key, item in value.items():@@ -703,6 +900,25 @@ def normalize_provision_spec(spec: Any) -> dict[str, Any]:tags = _string_list(spec.get("tags"), field="spec.tags") if "tags" in spec else []tags = _normalize_tags(tags)+ if "fields" in spec:+ raw_fields = spec.get("fields")+ if not isinstance(raw_fields, list):+ raise VaultServiceError("spec.fields must be an array of field names")+ fields = [_validate_field_name(item, field="spec.fields") for item in raw_fields]+ if len(fields) != len(set(fields)):+ raise VaultServiceError("spec.fields must contain unique field names")+ if not fields:+ raise VaultServiceError("spec.fields must contain at least one field")+ if len(fields) > MAX_SECRET_FIELDS:+ raise TooManyFieldsError(f"a vault secret can have at most {MAX_SECRET_FIELDS} fields")+ normalized["fields"] = fields+ default_field = spec.get("default_field", fields[0])+ default_field = _validate_field_name(default_field, field="spec.default_field")+ if default_field not in fields:+ raise VaultServiceError("spec.default_field must be one of spec.fields")+ normalized["default_field"] = default_field+ elif "default_field" in spec:+ raise VaultServiceError("spec.default_field requires spec.fields")if "policy" in spec:normalized_policy = _normalize_fetch_policy(spec.get("policy"), field="spec.policy")if normalized_policy:@@ -733,7 +949,7 @@ def _meta_payload(row: dict[str, Any]) -> dict[str, Any]:kind = row.get("kind")protection = row.get("protection")payload = {- "name": row["name"],+ **_field_metadata(row),"tags": _row_tags(row),"kind": kind,"protection": protection,@@ -775,10 +991,16 @@ def _row_sealed(row: dict[str, Any]) -> Sealed:def _protected_unlock_material(row: dict[str, Any]) -> dict[str, Any] | None:+ """Return the default record's opaque protected unlock material.++ This single-object shape is still used by signing and reveal cards. Grant+ options use ``_protected_unlock_material_records`` so every record is+ covered without changing this legacy surface.+ """if row.get("protection") != "protected":return Nonereturn {- "name": row["name"],+ "name": str(row["name"]),"kind": row.get("kind"),"envelope": {"ciphertext": row["ciphertext"],@@ -788,6 +1010,27 @@ def _protected_unlock_material(row: dict[str, Any]) -> dict[str, Any] | None:}+def _protected_unlock_material_records(row: dict[str, Any]) -> list[dict[str, Any]]:+ if row.get("protection") != "protected":+ return []+ materials: list[dict[str, Any]] = []+ for entry in _record_entries(row):+ envelope = entry["envelope"]+ materials.append(+ {+ "name": entry["name"],+ "field": entry["field"],+ "kind": row.get("kind"),+ "envelope": {+ "ciphertext": envelope.ciphertext,+ "nonce": envelope.nonce,+ "wrap_meta": envelope.wrap_meta,+ },+ }+ )+ return materials++def _member_version(row: dict[str, Any]) -> dict[str, Any]:return {"name": row["name"],@@ -1037,13 +1280,25 @@ def _unique_grant_release_refs(rows: list[dict[str, Any]]) -> list[dict[str, strreturn refs+def _field_metadata(row: dict[str, Any]) -> dict[str, Any]:+ default_field = _default_field_name(row)+ payload = {"name": str(row["name"]), "kind": str(row.get("kind") or "static"), "default_field": default_field, "fields": [default_field]}+ try:+ payload["fields"].extend(item["name"] for item in _extra_field_rows(row, strict=True))+ except FieldsCorruptError:+ payload["fields_state"] = "corrupt"+ return payload++def _hydrate_card_unlock_material(conn: Connection, row: dict[str, Any], card: dict[str, Any]) -> dict[str, Any]:card = dict(card)secret_name = row.get("secret_name")if secret_name:secret_row = conn.execute(select(vault_secrets).where(vault_secrets.c.name == secret_name)).mappings().first()- if secret_row is not None and (material := _protected_unlock_material(dict(secret_row))) is not None:- card["secret_unlock_material"] = material+ if secret_row is not None:+ material = _protected_unlock_material(dict(secret_row))+ if material is not None:+ card["secret_unlock_material"] = materialhydrated_options: list[dict[str, Any]] = []for option in card.get("grant_options") or []:if not isinstance(option, dict):@@ -1057,15 +1312,24 @@ def _hydrate_card_unlock_material(conn: Connection, row: dict[str, Any], card: dcurrent["name"]: dict(current)for current in conn.execute(select(vault_secrets).where(vault_secrets.c.name.in_(names))).mappings()}+ snapshots = {+ str(item["name"]): item for item in option_payload.get("member_fields") or []+ if isinstance(item, dict) and isinstance(item.get("name"), str)+ }+ # Labels are display metadata, not the frozen authorization member set.+ # In particular, a default rename deliberately preserves this request.+ option_payload["member_fields"] = [+ _field_metadata(current_rows[name]) if name in current_rows else snapshots[name]+ for name in option_payload.get("member_snapshot") or names+ if name in current_rows or name in snapshots+ ]for version in versions:if not isinstance(version, dict):continuecurrent = current_rows.get(version.get("name"))if current is None or not _member_version_matches(current, version):continue- material = _protected_unlock_material(current)- if material is not None:- materials.append(material)+ materials.extend(_protected_unlock_material_records(current))if materials:option_payload["unlock_material"] = materialshydrated_options.append(option_payload)@@ -1414,6 +1678,30 @@ def _request_callback_disabled(row: dict[str, Any]) -> bool:return bool(isinstance(requester, dict) and requester.get("callback_disabled"))+def has_named_field_shape(metadata: dict[str, Any]) -> bool:+ """Whether provision guidance needs a field-aware hint instead of legacy NAME."""+ if str(metadata.get("kind") or "static") == "keypair":+ return False+ default_field = str(metadata.get("default_field") or "value")+ fields = list(metadata.get("fields") or [default_field])+ return metadata.get("fields_state") == "corrupt" or fields != ["value"] or default_field != "value"+++def provision_field_hint(metadata: dict[str, Any]) -> str:+ """Value-free current-field usage shared by synchronous and async provision replies."""+ name = str(metadata["name"])+ fields = list(metadata.get("fields") or [metadata.get("default_field") or "value"])+ default_field = str(metadata.get("default_field") or fields[0])+ labels = ", ".join(str(field) for field in fields)+ usage = (+ f" Current fields: {labels}. Default alias: `{name}.{default_field}`."+ f" Select a field with `vibe vault run --env {name}.{fields[-1]} -- <command>`."+ )+ if metadata.get("fields_state") == "corrupt":+ return usage + " Extra fields are unavailable because their stored metadata is corrupt."+ return usage + " Tag and skill selectors deliver every field."++def _build_request_callback_message(row: dict[str, Any]) -> str:"""Agent-facing text delivered to the requesting session when a request resolves."""request_type = str(row.get("request_type") or "")@@ -1430,6 +1718,9 @@ def _build_request_callback_message(row: dict[str, Any]) -> str:if status in {"approved", "fulfilled"}:if request_type == "provision":usage = f" You can use it, e.g. `vibe vault run --env {name} -- <command>`." if name else ""+ current = row.get("provision_secret")+ if name and isinstance(current, dict) and has_named_field_shape(current):+ usage = provision_field_hint(current)return f"The user provided your {subject}; the secret is now available.{usage} Continue the task."if request_type == "access":return f"The user approved your {subject}; the grant is ready. Continue the task."@@ -1577,8 +1868,22 @@ def list_pending_request_callbacks(query = query.order_by(vault_requests.c.decided_at, vault_requests.c.id)if limit is not None:query = query.limit(limit)- rows = conn.execute(query).mappings()- return [dict(row) for row in rows]+ rows = [dict(row) for row in conn.execute(query).mappings()]+ for row in rows:+ if row.get("request_type") != "provision" or row.get("status") != "fulfilled":+ continue+ # Transient callback projection: use the user's actual current fields,+ # never the requested hints and never any envelope/value material.+ secret = conn.execute(+ select(vault_secrets.c.name, vault_secrets.c.kind, vault_secrets.c.id,+ vault_secrets.c.public_meta, vault_secrets.c.fields, vault_secrets.c.updated_at)+ .where(vault_secrets.c.name == row.get("secret_name"))+ ).mappings().first()+ if secret is not None:+ current = _field_metadata(dict(secret))+ if has_named_field_shape(current):+ row["provision_secret"] = current+ return rowsdef mark_request_callback(conn: Connection, request_id: str, *, status: str) -> None:@@ -2368,6 +2673,8 @@ def create_secret(source: str = "manual",policy: dict[str, Any] | None = None,public_meta: dict[str, Any] | None = None,+ fields: list[dict[str, Any]] | None = None,+ default_field: str | None = None,establishing_vmk: bool = False,authz_factor_registration: dict[str, Any] | None = None,authz_factor_origin: str | None = None,@@ -2436,6 +2743,42 @@ def create_secret(public_meta = dict(public_meta or {})if description:public_meta["description"] = description+ if kind == "keypair" and (fields or default_field is not None or "default_field" in public_meta):+ raise FieldsNotSupportedError("keypair secrets do not support fields or default_field")+ normalized_default_field = _default_field_name(value=default_field or public_meta.get("default_field"))+ if default_field is not None:+ _validate_field_name(default_field, field="default_field")+ raw_fields = [] if fields is None else fields+ if not isinstance(raw_fields, list):+ raise VaultServiceError("fields must be an array")+ if len(raw_fields) + 1 > MAX_SECRET_FIELDS:+ raise TooManyFieldsError(f"a vault secret can have at most {MAX_SECRET_FIELDS} fields")+ stored_fields: list[dict[str, Any]] = []+ field_names_seen: set[str] = {normalized_default_field}+ for raw_field in raw_fields:+ if not isinstance(raw_field, dict):+ raise VaultServiceError("fields entries must be objects")+ field_name = _validate_field_name(raw_field.get("name"), field="field name")+ if field_name in field_names_seen:+ raise FieldExistsError(f"field {field_name!r} already exists on {name}")+ if raw_field.get("record", f"{name}.{field_name}") != f"{name}.{field_name}":+ raise RecordMismatchError(f"record does not match field {field_name!r} on {name}")+ envelope = raw_field.get("sealed") or raw_field.get("envelope")+ if not isinstance(envelope, Sealed):+ raise VaultServiceError("fields entries require sealed envelopes")+ field_names_seen.add(field_name)+ stored_fields.append({+ "name": field_name,+ "ciphertext": envelope.ciphertext,+ "nonce": envelope.nonce,+ "wrap_meta": envelope.wrap_meta,+ "created_at": now,+ "updated_at": now,+ })+ if normalized_default_field == "value":+ public_meta.pop("default_field", None)+ else:+ public_meta["default_field"] = normalized_default_fieldtry:conn.execute(vault_secrets.insert().values(@@ -2449,6 +2792,7 @@ def create_secret(ciphertext=sealed.ciphertext,nonce=sealed.nonce,wrap_meta=sealed.wrap_meta,+ fields=json.dumps(stored_fields) if stored_fields else None,public_meta=json.dumps(public_meta) if public_meta else None,policy=json.dumps(policy) if policy else None,use_count=0,@@ -2534,6 +2878,7 @@ def update_secret_metadata(description: Any = _UNSET,tags: Any = _UNSET,policy: Any = _UNSET,+ default_field: Any = _UNSET,cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,release_scopes: list[dict[str, str]] | None = None,user_context: Any = None,@@ -2549,6 +2894,8 @@ def update_secret_metadata(row = _require_secret_resource_management(conn, _require_row(conn, secret_name), context)values: dict[str, Any] = {}fields: list[str] = []+ public_meta: dict[str, Any] | None = None+ policy_changed = Falseif description is not _UNSET:public_meta = _public_meta(row.get("public_meta"))@@ -2557,7 +2904,6 @@ def update_secret_metadata(public_meta["description"] = normalized_descriptionelse:public_meta.pop("description", None)- values["public_meta"] = json.dumps(public_meta) if public_meta else Nonefields.append("description")if tags is not _UNSET:@@ -2565,6 +2911,23 @@ def update_secret_metadata(values["tags"] = json.dumps(normalized_tags) if normalized_tags else Nonefields.append("tags")+ if default_field is not _UNSET:+ if row.get("kind") == "keypair":+ raise FieldsNotSupportedError("keypair secrets do not support default_field")+ normalized_default = _validate_field_name(default_field, field="default_field")+ extras = _extra_field_rows(row, strict=True)+ existing_default = _default_field_name(row)+ if normalized_default != existing_default:+ if normalized_default in {str(item["name"]) for item in extras}:+ raise FieldExistsError(f"field {normalized_default!r} already exists on {secret_name}")+ if public_meta is None:+ public_meta = _public_meta(row.get("public_meta"))+ if normalized_default == "value":+ public_meta.pop("default_field", None)+ else:+ public_meta["default_field"] = normalized_default+ fields.append("default_field")+if policy is not _UNSET:if policy is None:policy = {}@@ -2592,16 +2955,34 @@ def update_secret_metadata(values["policy"] = json.dumps(next_policy) if next_policy else Nonefields.append("policy")if normalized_policy != existing_visible_policy:- grant_rows = active_grant_rows_for_secret(conn, secret_name)- _expire_pending_requests_for_secret(conn, secret_name, reason="request-expired-policy-changed")- _expire_grant_rows(conn, grant_rows, cache=cache, reason="grant-expired-policy-changed")- if release_scopes is not None:- release_scopes.extend(agent_release_scopes_after_rows(conn, grant_rows, cache=cache))+ policy_changed = True++ if public_meta is not None:+ values["public_meta"] = json.dumps(public_meta) if public_meta else Noneif not values:return _meta_payload(row)- conn.execute(vault_secrets.update().where(vault_secrets.c.name == secret_name).values(**values))+ # Display metadata does not change the envelopes or their approval versions.+ # Compare the written columns as well, since those edits share that version.+ compared_columns = list(values)+ result = conn.execute(+ vault_secrets.update()+ .where(+ vault_secrets.c.id == row["id"],+ vault_secrets.c.updated_at == row["updated_at"],+ *(vault_secrets.c[key] == row.get(key) for key in compared_columns),+ )+ .values(**values)+ )+ if result.rowcount != 1:+ raise SecretConflictError(f"secret {secret_name!r} changed while metadata was being updated")+ if policy_changed:+ policy_grant_rows = active_grant_rows_for_secret(conn, secret_name)+ _expire_pending_requests_for_secret(conn, secret_name, reason="request-expired-policy-changed")+ _expire_grant_rows(conn, policy_grant_rows, cache=cache, reason="grant-expired-policy-changed")+ if release_scopes is not None:+ release_scopes.extend(agent_release_scopes_after_rows(conn, policy_grant_rows, cache=cache))audit(conn, "metadata-updated", secret_name=secret_name, delivery={"fields": fields})return _meta_payload(_require_row(conn, secret_name))@@ -2687,11 +3068,17 @@ def store_pubkey_pin(for key, value in pin.items()if key in {"public_key", "fingerprint", "attested_at", "attestation"}}- conn.execute(+ result = conn.execute(vault_secrets.update()- .where(vault_secrets.c.name == name)+ .where(+ vault_secrets.c.id == row["id"],+ vault_secrets.c.updated_at == row["updated_at"],+ vault_secrets.c.public_meta == row.get("public_meta"),+ ).values(public_meta=json.dumps(public_meta)))+ if result.rowcount != 1:+ raise SecretConflictError(f"secret {name!r} changed while metadata was being updated")audit(conn,"pubkey_pinned",@@ -2723,6 +3110,10 @@ def _searchable_secret_text(secret: dict[str, Any]) -> str:secret.get("signer_kind"),secret.get("description"),secret.get("tags"),+ secret.get("default_field"),+ secret.get("fields"),+ secret_record_names(secret),+ f"{secret.get('name')}.{secret.get('default_field') or 'value'}",]policy = secret.get("policy")if isinstance(policy, dict):@@ -2841,25 +3232,162 @@ def rotate_secret() -> dict[str, Any]:context = resolve_resource_access_context(user_context)row = _require_secret_resource_management(conn, _require_row(conn, name), context)+ _extra_field_rows(row, strict=True)public_meta = _public_meta(row.get("public_meta"))public_meta.pop("preview", None)- _expire_pending_requests_for_secret(conn, name, reason="request-expired-envelope-changed")- _expire_active_grants_for_secret(conn, name, cache=cache, reason="grant-expired-envelope-changed")- conn.execute(+ result = conn.execute(vault_secrets.update()- .where(vault_secrets.c.name == name)+ .where(+ vault_secrets.c.id == row["id"],+ vault_secrets.c.updated_at == row["updated_at"],+ vault_secrets.c.public_meta == row.get("public_meta"),+ ).values(ciphertext=sealed.ciphertext,nonce=sealed.nonce,wrap_meta=sealed.wrap_meta,public_meta=json.dumps(public_meta) if public_meta else None,- updated_at=_now(),+ updated_at=_next_updated_at(str(row.get("updated_at") or "")),))+ if result.rowcount != 1:+ raise SecretConflictError(f"secret {name!r} changed while its value was being updated")+ _expire_pending_requests_for_secret(conn, name, reason="request-expired-envelope-changed")+ _expire_active_grants_for_secret(conn, name, cache=cache, reason="grant-expired-envelope-changed")audit(conn, "updated", secret_name=name)return _meta_payload(_require_row(conn, name))+def _expire_envelope_change(+ conn: Connection,+ secret_name: str,+ *,+ cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,+ release_scopes: list[dict[str, str]] | None = None,+) -> None:+ _expire_pending_requests_for_secret(conn, secret_name, reason="request-expired-envelope-changed")+ grant_rows = active_grant_rows_for_secret(conn, secret_name)+ _expire_grant_rows(conn, grant_rows, cache=cache, reason="grant-expired-envelope-changed")+ if release_scopes is not None:+ release_scopes.extend(agent_release_scopes_after_rows(conn, grant_rows, cache=cache))+++def _stored_fields_json(fields: list[dict[str, Any]]) -> str | None:+ return json.dumps(fields) if fields else None+++def _require_field_record(row: dict[str, Any], field_name: str, record: str) -> None:+ expected = record_name_for_field(str(row["name"]), field_name, default_field=_default_field_name(row))+ if record != expected:+ raise RecordMismatchError(f"record does not match field {field_name!r} on {row['name']}")+++def update_secret_field(+ conn: Connection,+ secret_name: str,+ field_name: str,+ sealed: Sealed,+ *,+ record: str,+ expected_updated_at: str | None = None,+ cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,+ release_scopes: list[dict[str, str]] | None = None,+ user_context: Any = None,+) -> dict[str, Any]:+ context = resolve_resource_access_context(user_context)+ row = _require_secret_resource_management(conn, _require_row(conn, secret_name), context)+ field_name = _validate_field_name(field_name)+ snapshot_updated_at = row.get("updated_at")+ if expected_updated_at is not None and snapshot_updated_at != expected_updated_at:+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being updated")+ if row.get("kind") == "keypair":+ raise FieldsNotSupportedError(f"{secret_name} does not support fields")+ _require_field_record(row, field_name, record)+ default_field = _default_field_name(row)+ extras = _extra_field_rows(row, strict=True)+ extra_by_name = {str(item["name"]): item for item in extras}+ now = _next_updated_at(snapshot_updated_at)+ if field_name == default_field:+ values = {"ciphertext": sealed.ciphertext, "nonce": sealed.nonce, "wrap_meta": sealed.wrap_meta}+ op = "replace"+ else:+ existing = extra_by_name.get(field_name)+ if existing is None:+ if len(extras) + 1 >= MAX_SECRET_FIELDS:+ raise TooManyFieldsError(f"a vault secret can have at most {MAX_SECRET_FIELDS} fields")+ extras.append({+ "name": field_name,+ "ciphertext": sealed.ciphertext,+ "nonce": sealed.nonce,+ "wrap_meta": sealed.wrap_meta,+ "created_at": now,+ "updated_at": now,+ })+ op = "add"+ else:+ existing.update({"ciphertext": sealed.ciphertext, "nonce": sealed.nonce, "wrap_meta": sealed.wrap_meta, "updated_at": now})+ op = "replace"+ values = {"fields": _stored_fields_json(extras)}+ values["updated_at"] = now+ stmt = vault_secrets.update().where(+ vault_secrets.c.id == row["id"],+ vault_secrets.c.updated_at == snapshot_updated_at,+ vault_secrets.c.public_meta == row.get("public_meta"),+ )+ result = conn.execute(stmt.values(**values))+ if result.rowcount != 1:+ # A rename can race this transaction after its initial read without+ # changing updated_at. Never store an envelope under the wrong record.+ current = _require_row(conn, secret_name)+ if current.get("id") == row.get("id"):+ _require_field_record(current, field_name, record)+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being updated")+ _expire_envelope_change(conn, secret_name, cache=cache, release_scopes=release_scopes)+ audit(conn, "updated", secret_name=secret_name, delivery={"field": field_name, "op": op})+ return _meta_payload(_require_row(conn, secret_name))+++def remove_secret_field(+ conn: Connection,+ secret_name: str,+ field_name: str,+ *,+ expected_updated_at: str | None = None,+ cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,+ release_scopes: list[dict[str, str]] | None = None,+ user_context: Any = None,+) -> dict[str, Any]:+ context = resolve_resource_access_context(user_context)+ row = _require_secret_resource_management(conn, _require_row(conn, secret_name), context)+ field_name = _validate_field_name(field_name)+ snapshot_updated_at = row.get("updated_at")+ if expected_updated_at is not None and snapshot_updated_at != expected_updated_at:+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being removed")+ if row.get("kind") == "keypair":+ raise FieldsNotSupportedError(f"{secret_name} does not support fields")+ if field_name == _default_field_name(row):+ raise InvalidRequestError("the default field cannot be removed")+ extras = _extra_field_rows(row, strict=True)+ if not any(str(item["name"]) == field_name for item in extras):+ raise FieldNotFoundError(f"field {field_name!r} not found on {secret_name}; fields: {', '.join(secret_field_names(row))}")+ extras = [item for item in extras if str(item["name"]) != field_name]+ stmt = vault_secrets.update().where(+ vault_secrets.c.id == row["id"],+ vault_secrets.c.updated_at == snapshot_updated_at,+ )+ result = conn.execute(+ stmt.values(+ fields=_stored_fields_json(extras),+ updated_at=_next_updated_at(str(snapshot_updated_at or "")),+ )+ )+ if result.rowcount != 1:+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being removed")+ _expire_envelope_change(conn, secret_name, cache=cache, release_scopes=release_scopes)+ audit(conn, "updated", secret_name=secret_name, delivery={"field": field_name, "op": "remove"})+ return _meta_payload(_require_row(conn, secret_name))++def _disable_webauthn_factors_if_vault_deestablished(conn: Connection) -> None:protected_row = conn.execute(select(vault_secrets.c.id).where(vault_secrets.c.protection == "protected").limit(1)@@ -2900,51 +3428,41 @@ def delete_secret(def get_secret_policy(conn: Connection, name: str, *, user_context: Any = None) -> dict[str, Any]:"""Return the secret's non-secret policy dict (allowed_hosts, auth scheme)."""- return _loads(require_secret_access(conn, name, user_context=user_context).get("policy")) or {}+ row, _entry = _resolve_record_ref(conn, name, user_context=user_context)+ return _loads(row.get("policy")) or {}def get_envelope(conn: Connection, name: str, *, user_context: Any = None) -> Sealed:- """Return one standard-tier secret's stored envelope (no decrypt, no audit).-- For the brokered ``fetch`` proxy: the caller hands the envelope to the avault- client (which decrypts + delivers), then records its own ``record_proxy_use``.- Validate any policy (e.g. host allowlist) *before* delivering.-- Protected delivery must go through :func:`resolve_secret_access` and the- resident avault agent so Python never opens released DEKs or plaintext.- """- row = require_secret_access(conn, name, user_context=user_context)+ """Return one standard-tier record envelope for ``NAME`` or ``NAME.field``."""+ row, entry = _resolve_record_ref(conn, name, user_context=user_context)if row.get("protection") != "standard":raise UnsupportedProtectionError(f"{name} is protected-tier; use resident-agent grant delivery")- _reject_keypair_value_delivery(row, name)- return _row_sealed(row)+ _reject_keypair_value_delivery(row, str(row["name"]))+ return entry["envelope"]def get_protected_envelope(conn: Connection, name: str, *, user_context: Any = None) -> Sealed:- row = require_secret_access(conn, name, user_context=user_context)+ row, entry = _resolve_record_ref(conn, name, user_context=user_context)if row.get("protection") != "protected":raise UnsupportedProtectionError(f"{name} is standard-tier")- _reject_keypair_value_delivery(row, name)- return _row_sealed(row)+ _reject_keypair_value_delivery(row, str(row["name"]))+ return entry["envelope"]def get_protected_record_envelope(conn: Connection, name: str, *, user_context: Any = None) -> Sealed:- row = require_secret_access(conn, name, user_context=user_context)- if row.get("protection") != "protected":- raise UnsupportedProtectionError(f"{name} is standard-tier")- _reject_keypair_value_delivery(row, name)- return _row_sealed(row)+ return get_protected_envelope(conn, name, user_context=user_context)-def record_proxy_use(conn: Connection, name: str, *, requester: Any = None, delivery: Any = None) -> None:- """Bump usage + write a value-free ``proxied`` audit row after a brokered request."""- row = _require_row(conn, name)+def record_proxy_use(conn: Connection, identity: DeliveryIdentity, *, requester: Any = None, delivery: Any = None) -> None:+ """Record an actual egress from its pre-handoff identity, even after deletion."""conn.execute(vault_secrets.update()- .where(vault_secrets.c.name == name)+ .where(vault_secrets.c.id == identity.secret_id).values(last_used_at=_now(), use_count=vault_secrets.c.use_count + 1))- audit(conn, "proxied", secret_name=name, requester=requester, delivery=delivery)+ delivery_payload = dict(delivery) if isinstance(delivery, dict) else {}+ delivery_payload["field"] = identity.field+ audit(conn, "proxied", secret_name=identity.name, requester=requester, delivery=delivery_payload, access_snapshot=identity.access_snapshot)def record_signing_use(@@ -2974,13 +3492,23 @@ def record_reveal_use(request_id: str | None = None,) -> None:"""Bump revealed secret usage + write a value-free ``revealed`` audit row."""- _require_row(conn, name)+ row, entry = _resolve_record_ref(conn, name)+ secret_name = str(row["name"])conn.execute(vault_secrets.update()- .where(vault_secrets.c.name == name)+ .where(vault_secrets.c.name == secret_name).values(last_used_at=_now(), use_count=vault_secrets.c.use_count + 1))- audit(conn, "revealed", secret_name=name, requester=requester, delivery=delivery, request_id=request_id)+ delivery_payload = dict(delivery) if isinstance(delivery, dict) else {}+ delivery_payload["field"] = str(entry["field"])+ audit(+ conn,+ "revealed",+ secret_name=secret_name,+ requester=requester,+ delivery=delivery_payload,+ request_id=request_id,+ )def get_envelopes(conn: Connection, names: list[str], *, user_context: Any = None) -> dict[str, Sealed]:@@ -2994,12 +3522,12 @@ def get_envelopes(conn: Connection, names: list[str], *, user_context: Any = Non"""context = resolve_resource_access_context(user_context)out: dict[str, Sealed] = {}- for name in names:- row = _require_secret_resource_access(conn, _require_row(conn, name), context)+ for ref in names:+ row, entry = _resolve_record_ref(conn, ref, user_context=context)if row.get("protection") != "standard":- raise UnsupportedProtectionError(f"{name} is protected-tier; use resident-agent grant delivery")- _reject_keypair_value_delivery(row, name)- out[name] = _row_sealed(row)+ raise UnsupportedProtectionError(f"{ref} is protected-tier; use resident-agent grant delivery")+ _reject_keypair_value_delivery(row, str(row["name"]))+ out[str(entry["name"])] = entry["envelope"]return out@@ -3024,19 +3552,40 @@ def get_signing_envelope(conn: Connection, name: str, *, user_context: Any = Nonreturn get_key_envelope(conn, name, user_context=user_context)-def record_deliveries(conn: Connection, names: list[str], *, requester: Any = None, mode: str | None = None) -> None:- """Bump usage + write a value-free ``delivered`` audit row per name.-- Call this only AFTER the delivery action (child spawn / file write / stream) succeeds,- so the audit trail and usage counts never record a delivery that didn't happen.- """- for name in names:+def capture_delivery_identities(conn: Connection, refs: list[str], *, user_context: Any = None) -> list[DeliveryIdentity]:+ """Capture labels and ACL identity while the selected records still exist."""+ identities: list[DeliveryIdentity] = []+ snapshots: dict[str, dict[str, Any] | None] = {}+ for ref in refs:+ row, entry = _resolve_record_ref(conn, ref, user_context=user_context)+ name = str(row["name"])+ if name not in snapshots:+ snapshots[name] = _build_audit_access_snapshot(conn, [name])+ identities.append(DeliveryIdentity(str(row["id"]), name, str(entry["field"]), snapshots[name]))+ return identities+++def record_deliveries(conn: Connection, identities: list[DeliveryIdentity], *, requester: Any = None, mode: str | None = None) -> None:+ """Bookkeep a completed handoff without resolving records a second time."""+ delivered: dict[str, tuple[DeliveryIdentity, list[str]]] = {}+ for identity in identities:+ _, fields = delivered.setdefault(identity.secret_id, (identity, []))+ if identity.field not in fields:+ fields.append(identity.field)+ for identity, fields in delivered.values():conn.execute(vault_secrets.update()- .where(vault_secrets.c.name == name)+ .where(vault_secrets.c.id == identity.secret_id).values(last_used_at=_now(), use_count=vault_secrets.c.use_count + 1))- audit(conn, "delivered", secret_name=name, requester=requester, delivery={"mode": mode})+ audit(+ conn,+ "delivered",+ secret_name=identity.name,+ requester=requester,+ delivery={"mode": mode, "fields": fields},+ access_snapshot=identity.access_snapshot,+ )def _active_session_turn_anchor(@@ -3219,14 +3768,20 @@ def _parse_env_selector(spec: str) -> tuple[str, str]:if not raw:raise InvalidRequestError("env selector must be non-empty")if "=" in raw:- env_name, secret_name = raw.split("=", 1)+ env_name, record_ref = raw.split("=", 1)env_name = env_name.strip()- secret_name = secret_name.strip()+ record_ref = record_ref.strip()+ if not env_name:+ raise InvalidRequestError("env selector alias must be non-empty")else:- env_name = secret_name = raw- if not _is_delivery_env_name(env_name) or not vault_crypto.is_valid_secret_name(secret_name):+ record_ref = raw+ base, separator, field = record_ref.partition(".")+ env_name = base if not separator else f"{base}_{field.upper()}"+ if not _is_delivery_env_name(env_name):+ raise InvalidRequestError("env selector must use a valid env alias and secret name")+ if not vault_crypto.is_valid_secret_name(record_ref.split(".", 1)[0]):raise InvalidRequestError("env selector must use a valid env alias and secret name")- return env_name, secret_name+ return env_name, record_refdef _is_delivery_env_name(name: str) -> bool:@@ -3247,26 +3802,29 @@ def expand_value_delivery_selector(selector = _source_selector_payload(source_selector or {"env": env or [], "tags": tags or [], "skills": skills or []})context = resolve_resource_access_context(user_context)selections: list[dict[str, Any]] = []- env_by_secret: dict[str, str] = {}- secret_by_env: dict[str, str] = {}+ env_by_record: dict[str, str] = {}+ record_by_env: dict[str, str] = {}- def add_selection(row: dict[str, Any], env_name: str) -> None:+ def add_selection(row: dict[str, Any], entry: dict[str, Any], env_name: str) -> None:_require_secret_resource_access(conn, row, context)secret_name = str(row["name"])_reject_keypair_value_delivery(row, secret_name)- existing_env = env_by_secret.get(secret_name)+ record = str(entry["name"])+ existing_env = env_by_record.get(record)if existing_env is not None:if existing_env != env_name:- raise InvalidRequestError(f"{secret_name} was selected with conflicting env names")+ raise InvalidRequestError(f"{record} was selected with conflicting env names")return- existing_secret = secret_by_env.get(env_name)- if existing_secret is not None and existing_secret != secret_name:- raise InvalidRequestError(f"env {env_name} maps to multiple vault secrets")- env_by_secret[secret_name] = env_name- secret_by_env[env_name] = secret_name+ existing_record = record_by_env.get(env_name)+ if existing_record is not None and existing_record != record:+ raise InvalidRequestError(f"env {env_name} maps to multiple vault records")+ env_by_record[record] = env_name+ record_by_env[env_name] = recordselections.append({"name": secret_name,+ "field": str(entry["field"]),+ "record": record,"env": env_name,"kind": row.get("kind"),"protection": row.get("protection"),@@ -3274,8 +3832,9 @@ def expand_value_delivery_selector()for env_spec in selector.get("env") or []:- env_name, secret_name = _parse_env_selector(str(env_spec))- add_selection(_require_row(conn, secret_name), env_name)+ env_name, record_ref = _parse_env_selector(str(env_spec))+ row, entry = _resolve_record_ref(conn, record_ref, user_context=context)+ add_selection(row, entry, env_name)for tag in selector.get("tags") or []:normalized = _normalize_tag(str(tag))@@ -3285,7 +3844,11 @@ def expand_value_delivery_selector(if normalized in _row_tags(dict(row))]for row in rows:- add_selection(row, str(row["name"]))+ _require_secret_resource_access(conn, row, context)+ for entry in _record_entries(row, strict=True):+ field = str(entry["field"])+ env_name = str(row["name"]) if entry["name"] == row["name"] else f"{row['name']}_{field.upper()}"+ add_selection(row, entry, env_name)return {"source_selector": selector, "secrets": selections}@@ -3298,8 +3861,13 @@ def _request_member_rows_for_selector() -> list[dict[str, Any]]:expanded = expand_value_delivery_selector(conn, source_selector=source_selector, user_context=user_context)rows: list[dict[str, Any]] = []+ seen_names: set[str] = set()for item in expanded["secrets"]:- row = _require_row(conn, str(item["name"]))+ secret_name = str(item["name"])+ if secret_name in seen_names:+ continue+ seen_names.add(secret_name)+ row = _require_row(conn, secret_name)if row.get("protection") == "protected" or _secret_always_ask(row):rows.append(row)return rows@@ -3404,6 +3972,7 @@ def _grant_option("member_count": len(members),"member_snapshot": members,"member_versions": [_member_version(row) for row in rows],+ "member_fields": [_field_metadata(row) for row in rows],}if one_shot:option["one_shot"] = True@@ -3486,7 +4055,8 @@ def create_access_request(if protected_delivery_names:rows = _filter_request_rows_to_protected_names(rows, protected_delivery_names)if name:- direct_row = _require_secret_resource_access(conn, _require_row(conn, name), context)+ direct_row, _entry = _resolve_record_ref(conn, name, user_context=context)+ name = str(direct_row["name"])if not _secret_access_requestable(direct_row):raise NotGrantableError(f"{name} is not access-requestable")if not rows:@@ -3762,6 +4332,12 @@ def _agent_binding_approval_record_cap(row_dict: dict[str, Any], new_record: dicmembers = option.get("member_snapshot")if isinstance(members, list):member_count = max(member_count, len([name for name in members if isinstance(name, str) and name]))+ member_fields = option.get("member_fields")+ if isinstance(member_fields, list):+ member_count = max(+ member_count,+ sum(len(secret_record_names(meta)) for meta in member_fields if isinstance(meta, dict)),+ )return max(1, member_count, len(_agent_binding_record_item_names(new_record)))@@ -4923,10 +5499,12 @@ def resolve_secret_access(expire the grant and re-run this resolver to create a fresh approval request."""context = resolve_resource_access_context(user_context)- row = _require_secret_resource_access(conn, _require_row(conn, name), context)+ row, record_entry = _resolve_record_ref(conn, name, user_context=context)+ secret_name = str(row["name"])+ record_name = str(record_entry["name"])if purpose not in GRANT_PURPOSES:raise InvalidRequestError(f"invalid grant purpose: {purpose!r}")- _reject_keypair_value_delivery(row, name)+ _reject_keypair_value_delivery(row, secret_name)delivery_payload = dict(delivery or {})effective_session_id = (session_id@@ -4935,10 +5513,10 @@ def resolve_secret_access()always_ask = _secret_always_ask(row)if row.get("protection") == "standard" and not always_ask:- return {"status": "standard", "secret": _meta_payload(row), "envelope": _row_sealed(row)}+ return {"status": "standard", "secret": _meta_payload(row), "envelope": record_entry["envelope"]}grant = find_active_grant_for_secret(conn,- name,+ secret_name,session_id=effective_session_id,purpose=purpose,cache=cache,@@ -4949,7 +5527,7 @@ def resolve_secret_access("status": "standard" if row.get("protection") == "standard" else "agent_delivery_ready","secret": _meta_payload(row),"grant": grant,- "envelope": _row_sealed(row),+ "envelope": record_entry["envelope"],"request": None,}request_payload = None@@ -4958,8 +5536,8 @@ def resolve_secret_access(delivery_payload["session_id"] = effective_session_idrequest_payload = create_access_request(conn,- name,- source_selector={"env": [name]},+ secret_name,+ source_selector={"env": [record_name]},purpose=purpose,requester=requester,delivery=delivery_payload,diff --git a/tests/fixtures/member_management_existing_read_roles.json b/tests/fixtures/member_management_existing_read_roles.jsonindex 739fffec9..4f1dac65c 100644--- a/tests/fixtures/member_management_existing_read_roles.json+++ b/tests/fixtures/member_management_existing_read_roles.json@@ -8,6 +8,7 @@"DELETE /api/terminal/example": "viewer","DELETE /api/vault/grants/example": "editor","DELETE /api/vault/secrets/example": "editor",+ "DELETE /api/vault/secrets/example/fields/example": "editor","DELETE /api/web-push/subscriptions": "viewer","GET /api/agent-backends": "editor","GET /api/agents": "editor",@@ -137,5 +138,6 @@"POST /api/web-push/test": "viewer","PUT /api/dock/order": "editor","PUT /api/files/write": "editor",- "PUT /api/sessions/example/draft": "editor"+ "PUT /api/sessions/example/draft": "editor",+ "PUT /api/vault/secrets/example/fields/example": "editor"}diff --git a/tests/test_agent_context_seq_migration.py b/tests/test_agent_context_seq_migration.pyindex d1a8234e8..296a914eb 100644--- a/tests/test_agent_context_seq_migration.py+++ b/tests/test_agent_context_seq_migration.py@@ -56,7 +56,7 @@ def test_context_seq_upgrade_and_downgrade_keep_released_rows(tmp_path):migrations.run_migrations(path)with sqlite3.connect(path) as conn:- assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261012_0064",)+ assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261013_0065",)assert_released_rows_unchanged(conn)assert _index_sql(conn, "ix_agent_events_turn_sequence_id") is not Nonefor table, (first, same_session, other_session) in _IDS.items():diff --git a/tests/test_member_management_parity.py b/tests/test_member_management_parity.pyindex e94652d3c..083c065b6 100644--- a/tests/test_member_management_parity.py+++ b/tests/test_member_management_parity.py@@ -118,7 +118,10 @@ def test_complete_registered_api_management_inventory():for method in (getattr(route, "methods", None) or ())if method not in {"HEAD", "OPTIONS"}}- assert len(endpoints) == 283+ assert len(endpoints) == 285+ for method in ("PUT", "DELETE"):+ assert (method, "/api/vault/secrets/{name}/fields/{field}") in endpoints+ assert http_authorization_policy(method, "/api/vault/secrets/LOGIN/fields/username").minimum_role == "editor"assert http_authorization_policy("POST", "/api/desktop-mini/session").minimum_role == "editor"assert http_authorization_policy("GET", "/api/desktop/capabilities").minimum_role == "member"assert http_authorization_policy("GET", "/api/desktop/computer-use/status").minimum_role == "member"diff --git a/tests/test_resource_acl_vaults.py b/tests/test_resource_acl_vaults.pyindex bc19fb391..c5df4898e 100644--- a/tests/test_resource_acl_vaults.py+++ b/tests/test_resource_acl_vaults.py@@ -477,6 +477,8 @@ def test_active_org_member_resolves_private_secret_cli_selectors(vault, selectorassert expanded["secrets"] == [{"name": "PRIVATE_SELECTOR",+ "field": "value",+ "record": "PRIVATE_SELECTOR","env": "PRIVATE_SELECTOR","kind": "static","protection": "standard",@@ -735,6 +737,10 @@ def test_secret_management_follows_instance_manager_capability(vault, role):operations = (lambda: vault_service.update_secret_tags(conn, "MANAGED_KEY", ["test"], user_context=context),lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", description="managed", user_context=context),+ lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "username", _sealed("user"), record="MANAGED_KEY.username", user_context=context),+ lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "value", _sealed("default"), record="MANAGED_KEY", user_context=context),+ lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", default_field="password", user_context=context),+ lambda: vault_service.remove_secret_field(conn, "MANAGED_KEY", "username", user_context=context),lambda: vault_service.update_secret_classification(conn, "MANAGED_KEY", protection="protected", user_context=context),lambda: vault_service.store_pubkey_pin(conn, "MANAGED_KEY", {"fingerprint": "test-pin"}, user_context=context),lambda: vault_service.rotate_secret(conn, "MANAGED_KEY", _sealed("rotated"), user_context=context),diff --git a/tests/test_skill_observability_migration.py b/tests/test_skill_observability_migration.pyindex 5f566c2ee..9eb7a510b 100644--- a/tests/test_skill_observability_migration.py+++ b/tests/test_skill_observability_migration.py@@ -35,7 +35,7 @@ def test_skill_schema_upgrade_downgrade_preserves_existing_events(tmp_path):migrations.run_migrations(path)with sqlite3.connect(path) as conn:assert conn.execute(f"SELECT {columns} FROM agent_events ORDER BY id").fetchall() == original- assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261012_0064",)+ assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261013_0065",)assert conn.execute("SELECT count(*) FROM skill_usage_daily").fetchone() == (0,)assert {row[2] for row in conn.execute("PRAGMA foreign_key_list(skill_usage_daily)")} == {"scopes",diff --git a/tests/test_sqlite_state_migration.py b/tests/test_sqlite_state_migration.pyindex fbd2c5987..92dacdf82 100644--- a/tests/test_sqlite_state_migration.py+++ b/tests/test_sqlite_state_migration.py@@ -38,7 +38,7 @@ from vibe.message_types import build_partial_index_predicatepytestmark = pytest.mark.no_sqlite_template-HEAD_REVISION = "20261012_0064"+HEAD_REVISION = "20261013_0065"# ``storage.models`` builds a bare ``MetaData()``, so its foreign keys are unnamed and# Alembic cannot re-emit them when batch mode recreates a table. Every migration that# rebuilds one therefore passes this convention; the rebuild simulated below has to passdiff --git a/tests/test_vault_api.py b/tests/test_vault_api.pyindex 00aa70713..fbe9029ee 100644--- a/tests/test_vault_api.py+++ b/tests/test_vault_api.py@@ -2105,6 +2105,39 @@ def test_request_vault_access_malformed_selector_returns_vault_api_error():assert exc.value.status == 409[email protected]("selector,status,code", [+ ({"env": ["LOGIN.nope"]}, 404, "field_not_found"),+ ({"env": ["LOGIN.UPPER"]}, 400, "invalid_field_name"),+ ({"env": ["KEY.value"]}, 409, "fields_not_supported"),+ ({"tags": ["broken"]}, 409, "fields_corrupt"),+])+def test_access_request_preserves_record_error_codes(selector, status, code):+ with api._vault_engine().begin() as conn:+ vault_service.create_secret(conn, name="LOGIN", protection="protected", sealed=_sealed("default"))+ vault_service.create_secret(conn, name="KEY", kind="keypair", protection="protected", sealed=_sealed("key"))+ vault_service.create_secret(conn, name="BROKEN", protection="protected", tags=["broken"], sealed=_sealed("broken"))+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "BROKEN").values(fields="corrupt"))+ with pytest.raises(api.VaultApiError) as exc:+ api.request_vault_access({"source_selector": selector})+ assert (exc.value.status, exc.value.code) == (status, code)+ with api._vault_engine().connect() as conn:+ assert list(conn.execute(select(vault_service.vault_requests))) == []+++def test_direct_access_request_resolves_fields_and_keeps_secret_authorization():+ with api._vault_engine().begin() as conn:+ vault_service.create_secret(+ conn, name="LOGIN", protection="protected", default_field="password", sealed=_sealed("password"),+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ requested = api.request_vault_access({"name": "LOGIN.username"})["request"]+ assert requested["secret_name"] == "LOGIN"+ assert requested["card"]["grant_options"][0]["member_snapshot"] == ["LOGIN"]+ with pytest.raises(api.VaultApiError) as exc:+ api.request_vault_access({"name": "LOGIN.nope"})+ assert (exc.value.status, exc.value.code) == (404, "field_not_found")++def test_request_vault_access_reports_missing_selector_member_name():with pytest.raises(api.VaultApiError) as exc:api.request_vault_access({"source_selector": {"env": ["MISSING_KEY"]}, "session_id": "ses_1"})@@ -4321,3 +4354,397 @@ def test_vault_sign_rejects_malformed_digest_before_request_or_avault(monkeypatcassert exc.value.code == "invalid_digest"sign.assert_not_called()assert api.get_vault_requests()["requests"] == []++[email protected]("default_field", ["value", "password"])+def test_keypair_create_rejects_explicit_default_field(monkeypatch, default_field):+ seal = Mock(return_value=_sealed())+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)+ with pytest.raises(api.VaultApiError) as exc:+ api.create_vault_secret({+ "name": "KEY", "kind": "keypair", "default_field": default_field,+ "blind_box": _agent_dek_blindbox(),+ })+ assert exc.value.code == "fields_not_supported"+ seal.assert_not_called()+ assert api.get_vault_secrets()["secrets"] == []+++def test_keypair_patch_rejects_default_field_and_keeps_implicit_value():+ created = api.create_vault_secret({+ "name": "KEY", "kind": "keypair", "protection": "protected",+ "sealed": {"ciphertext": "ct-key", "nonce": "n-key", "wrap_meta": "wm-key"},+ })["secret"]+ with pytest.raises(api.VaultApiError) as exc:+ api.update_vault_secret("KEY", {"default_field": "private_key"})+ assert exc.value.code == "fields_not_supported"+ current = api.get_vault_secrets()["secrets"][0]+ assert current["default_field"] == "value"+ assert current["fields"] == ["value"]+ assert current["updated_at"] == created["updated_at"]+++def test_create_vault_secret_seals_each_standard_record_name(monkeypatch):+ seal = Mock(side_effect=[_sealed("default"), _sealed("username"), _sealed("totp")])+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)++ result = api.create_vault_secret(+ {+ "name": "LOGIN",+ "default_field": "password",+ "blind_box": _agent_dek_blindbox("default", "default"),+ "fields": [+ {+ "name": "username",+ "record": "LOGIN.username",+ "blind_box": _agent_dek_blindbox("username", "username"),+ },+ {+ "name": "totp",+ "record": "LOGIN.totp",+ "blind_box": _agent_dek_blindbox("totp", "totp"),+ },+ ],+ }+ )++ assert result["secret"]["default_field"] == "password"+ assert result["secret"]["fields"] == ["password", "username", "totp"]+ assert [call.args[0] for call in seal.call_args_list] == ["LOGIN", "LOGIN.username", "LOGIN.totp"]+ with api._vault_engine().connect() as conn:+ assert vault_service.get_envelope(conn, "LOGIN.username") == _sealed("username")+ assert vault_service.get_envelope(conn, "LOGIN.totp") == _sealed("totp")+++def test_vault_field_update_and_default_rename_are_value_free(monkeypatch):+ seal = Mock(side_effect=[_sealed("default"), _sealed("username")])+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)+ api.create_vault_secret(+ {+ "name": "LOGIN",+ "blind_box": _agent_dek_blindbox("default", "default"),+ }+ )+ updated = api.update_vault_secret_field(+ "LOGIN",+ "username",+ {+ "record": "LOGIN.username",+ "blind_box": _agent_dek_blindbox("username", "username"),+ },+ )++ assert updated["secret"]["fields"] == ["value", "username"]+ assert [call.args[0] for call in seal.call_args_list] == ["LOGIN", "LOGIN.username"]+ renamed = api.update_vault_secret("LOGIN", {"default_field": "password"})+ assert renamed["secret"]["default_field"] == "password"+ assert renamed["secret"]["fields"] == ["password", "username"]++ with pytest.raises(api.VaultApiError) as exc:+ api.update_vault_secret_field(+ "LOGIN",+ "totp",+ {+ "blind_box": _agent_dek_blindbox("totp", "totp"),+ "value": "plaintext",+ },+ )+ assert exc.value.code == "plaintext_value_rejected"+ assert [call.args[0] for call in seal.call_args_list] == ["LOGIN", "LOGIN.username"]+++ ("field", "code"),+ [+ ({"name": "username", "blind_box": _agent_dek_blindbox("username", "username")}, "invalid_request"),+ (+ {+ "name": "username",+ "record": "LOGIN",+ "blind_box": _agent_dek_blindbox("username", "username"),+ },+ "record_mismatch",+ ),+ ],+)+def test_create_extra_field_requires_matching_record(monkeypatch, field, code):+ seal = Mock(return_value=_sealed("default"))+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)++ with pytest.raises(api.VaultApiError) as exc:+ api.create_vault_secret(+ {+ "name": "LOGIN",+ "blind_box": _agent_dek_blindbox("default", "default"),+ "fields": [field],+ }+ )++ assert exc.value.code == code+ seal.assert_not_called()+ assert api.get_vault_secrets()["secrets"] == []+++def test_protected_field_put_rejects_stale_default_record_after_rename():+ api.create_vault_secret(+ {+ "name": "LOGIN",+ "protection": "protected",+ "sealed": {"ciphertext": "ct-old", "nonce": "n-old", "wrap_meta": "wm-old"},+ }+ )+ api.update_vault_secret("LOGIN", {"default_field": "password"})++ with api._vault_engine().connect() as conn:+ before = vault_service.get_protected_envelope(conn, "LOGIN")++ with pytest.raises(api.VaultApiError) as exc:+ api.update_vault_secret_field(+ "LOGIN",+ "value",+ {+ "record": "LOGIN",+ "sealed": {"ciphertext": "ct-new", "nonce": "n-new", "wrap_meta": "wm-new"},+ },+ )++ assert exc.value.code == "record_mismatch"+ with api._vault_engine().connect() as conn:+ assert vault_service.get_protected_envelope(conn, "LOGIN") == before+++def test_protected_field_put_record_guard_survives_concurrent_default_rename(monkeypatch):+ api.create_vault_secret(+ {+ "name": "LOGIN",+ "protection": "protected",+ "sealed": {"ciphertext": "ct-old", "nonce": "n-old", "wrap_meta": "wm-old"},+ }+ )+ original_sealed_from_payload = api._sealed_from_payload+ raced = False++ def seal_then_rename(payload):+ nonlocal raced+ sealed = original_sealed_from_payload(payload)+ if not raced:+ raced = True+ with api._vault_engine().begin() as conn:+ vault_service.update_secret_metadata(conn, "LOGIN", default_field="password")+ return sealed++ monkeypatch.setattr(api, "_sealed_from_payload", seal_then_rename)++ with pytest.raises(api.VaultApiError) as exc:+ api.update_vault_secret_field(+ "LOGIN",+ "value",+ {+ "record": "LOGIN",+ "sealed": {"ciphertext": "ct-raced", "nonce": "n-raced", "wrap_meta": "wm-raced"},+ },+ )++ assert exc.value.code == "record_mismatch"+ with api._vault_engine().connect() as conn:+ assert vault_service.get_protected_envelope(conn, "LOGIN") == _sealed("old")+++def test_protected_reveal_context_uses_field_record_name(monkeypatch):+ api.create_vault_secret(+ {+ "name": "PROTECTED_LOGIN",+ "protection": "protected",+ "default_field": "password",+ "sealed": {"ciphertext": "ct-password", "nonce": "n-password", "wrap_meta": "wm-password"},+ "fields": [+ {+ "name": "username",+ "record": "PROTECTED_LOGIN.username",+ "sealed": {"ciphertext": "ct-username", "nonce": "n-username", "wrap_meta": "wm-username"},+ }+ ],+ }+ )++ result = api.create_vault_reveal_context("PROTECTED_LOGIN", {"field": "username"})+ context = _verified_signed_context(result["context"])++ assert result["envelope"] == {+ "ciphertext": "ct-username",+ "nonce": "n-username",+ "wrap_meta": "wm-username",+ }+ assert context["release"]["name"] == "PROTECTED_LOGIN.username"+ assert context["display"]["secrets"] == [{"name": "PROTECTED_LOGIN.username", "kind": "static"}]+++def test_every_web_field_error_code_has_english_and_chinese_translations():+ codes = api._VAULT_FIELD_ERROR_CODES+ assert codes and len(codes) == len(set(codes))+ root = Path(__file__).resolve().parents[1]+ for language in ("en", "zh"):+ catalog = json.loads((root / "ui" / "src" / "i18n" / f"{language}.json").read_text(encoding="utf-8"))+ for code in codes:+ assert isinstance(catalog["errors"].get(code), str) and catalog["errors"][code].strip(), (language, code)++ # Probe the real translator for every service exception type, rather than a+ # second manually maintained list of field classes. Only type and message+ # matter to this boundary; storage-specific constructor data is not read.+ translated = set()+ for error_type in vars(vault_service).values():+ if isinstance(error_type, type) and issubclass(error_type, vault_service.VaultServiceError):+ error = Exception.__new__(error_type)+ Exception.__init__(error, "metadata error")+ translated.add(api._vault_field_service_error(error).code)+ generic_codes = {"vault_error", "invalid_request", "secret_not_found", "resource_access_forbidden"}+ assert translated - generic_codes == set(codes)+++def test_single_agent_binding_maps_corrupt_extra_fields_to_fields_corrupt(monkeypatch):+ agent_key = Mock(return_value=TEST_AGENT_PUBKEY)+ monkeypatch.setattr(api, "avault_agent_pubkey", agent_key)+ api.create_vault_secret({+ "name": "CORRUPT_BIND", "protection": "protected",+ "sealed": {"ciphertext": "ct", "nonce": "nonce", "wrap_meta": "wrap"},+ "fields": [{"name": "username", "record": "CORRUPT_BIND.username", "sealed": {"ciphertext": "ct-u", "nonce": "nonce-u", "wrap_meta": "wrap-u"}}],+ })+ request = api.request_vault_access({"name": "CORRUPT_BIND"})["request"]+ grant_id = request["card"]["grant_options"][0]["grant_id"]+ with api._vault_engine().begin() as conn:+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "CORRUPT_BIND").values(fields="invalid"))+ with pytest.raises(api.VaultApiError) as exc:+ api.create_vault_agent_binding({"name": "CORRUPT_BIND.username", "request_id": request["id"], "grant_id": grant_id})+ assert (exc.value.status, exc.value.code) == (409, "fields_corrupt")+ agent_key.assert_not_called()+++def test_corrupt_fields_return_stable_error_without_disabling_default_reveal():+ api.create_vault_secret({+ "name": "CORRUPT_LOGIN", "protection": "protected",+ "sealed": {"ciphertext": "ct-default", "nonce": "n-default", "wrap_meta": "wm-default"},+ })+ engine = api._vault_engine()+ damaged = '[{"name":"username","ciphertext":"retain-this-record"}]'+ with engine.begin() as conn:+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "CORRUPT_LOGIN").values(fields=damaged))+ for operation in (+ lambda: api.update_vault_secret("CORRUPT_LOGIN", {"default_field": "password"}),+ lambda: api.update_vault_secret_field("CORRUPT_LOGIN", "value", {+ "record": "CORRUPT_LOGIN",+ "sealed": {"ciphertext": "ct-new", "nonce": "n-new", "wrap_meta": "wm-new"},+ }),+ lambda: api.delete_vault_secret_field("CORRUPT_LOGIN", "username"),+ lambda: api.create_vault_reveal_context("CORRUPT_LOGIN", {"field": "username"}),+ ):+ with pytest.raises(api.VaultApiError) as exc:+ operation()+ assert (exc.value.status, exc.value.code) == (409, "fields_corrupt")+ assert api.create_vault_reveal_context("CORRUPT_LOGIN")["envelope"] == {+ "ciphertext": "ct-default", "nonce": "n-default", "wrap_meta": "wm-default",+ }+ with engine.connect() as conn:+ assert conn.execute(select(vault_secrets.c.fields).where(vault_secrets.c.name == "CORRUPT_LOGIN")).scalar_one() == damaged+++def test_store_vault_pubkey_pin_maps_storage_cas_conflict_to_409(monkeypatch):+ """A CAS conflict is a retryable API response, not an uncaught storage error."""+ pin = {"public_key": "test-public-key", "fingerprint": "test-fingerprint"}+ store = Mock(side_effect=vault_service.SecretConflictError("concurrent metadata update"))+ monkeypatch.setattr(vault_service, "store_pubkey_pin", store)+ publish = Mock()+ monkeypatch.setattr(api, "_publish_vaults_updated", publish)+ with pytest.raises(api.VaultApiError) as exc:+ api.store_vault_pubkey_pin({"name": "PINNED_KEY", "pin": pin})+ assert exc.value.status == 409+ assert exc.value.code == "secret_conflict"+ assert store.call_args.args[1:] == ("PINNED_KEY", pin)+ publish.assert_not_called()+++def test_protected_agent_binding_batch_expands_record_names(monkeypatch):+ monkeypatch.setattr(api, "_require_avault_grant_delivery_surface", lambda _feature: None)+ monkeypatch.setattr(api, "avault_agent_pubkey", Mock(return_value=TEST_AGENT_PUBKEY))+ api.create_vault_secret(+ {+ "name": "PROTECTED_LOGIN",+ "protection": "protected",+ "default_field": "password",+ "sealed": {"ciphertext": "ct-password", "nonce": "n-password", "wrap_meta": "wm-password"},+ "fields": [+ {+ "name": "username",+ "record": "PROTECTED_LOGIN.username",+ "sealed": {"ciphertext": "ct-username", "nonce": "n-username", "wrap_meta": "wm-username"},+ }+ ],+ }+ )+ requested = api.request_vault_access({"name": "PROTECTED_LOGIN", "session_id": "ses_1"})++ result = api.create_vault_agent_bindings_batch({"request_id": requested["request"]["id"], "grant_duration": 300})++ assert [item["name"] for item in result["items"]] == ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]+ display_names = [item["name"] for item in _verified_signed_context(result["items"][0]["context"])["display"]["secrets"]]+ assert display_names == ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]+ for item in result["items"]:+ context = _verified_signed_context(item["context"])+ assert context["release"]["operationHash"] == api._agent_deliver_operation_hash(item["name"], 300)+++def test_create_grant_relays_every_protected_record_and_rejects_missing_dek(monkeypatch, avault_p2):+ """Protect the grant boundary: every released record must reach avault by canonical name."""++ agent_grant = Mock(return_value={"granted": 3, "ttl_secs": 300})+ monkeypatch.setattr(api, "avault_agent_grant", agent_grant)+ api.create_vault_secret(+ {+ "name": "PROTECTED_LOGIN",+ "protection": "protected",+ "default_field": "password",+ "sealed": {"ciphertext": "ct-password", "nonce": "n-password", "wrap_meta": "wm-password"},+ "fields": [+ {+ "name": "username",+ "record": "PROTECTED_LOGIN.username",+ "sealed": {"ciphertext": "ct-username", "nonce": "n-username", "wrap_meta": "wm-username"},+ },+ {+ "name": "totp",+ "record": "PROTECTED_LOGIN.totp",+ "sealed": {"ciphertext": "ct-totp", "nonce": "n-totp", "wrap_meta": "wm-totp"},+ },+ ],+ }+ )+ requested = api.request_vault_access({"name": "PROTECTED_LOGIN", "session_id": "ses_1"})+ issued = _issued_agent_dek_payload(requested["request"]["id"])++ with pytest.raises(api.VaultApiError) as exc:+ api.create_vault_grant(+ {+ "session_id": "ses_1",+ "request_id": requested["request"]["id"],+ **issued,+ "deks": issued["deks"][:-1],+ }+ )++ assert exc.value.code == "invalid_grant"+ agent_grant.assert_not_called()++ created = api.create_vault_grant(+ {+ "session_id": "ses_1",+ "request_id": requested["request"]["id"],+ **issued,+ }+ )++ assert created["grant"]["status"] == "active"+ assert created["grant"]["member_snapshot"] == ["PROTECTED_LOGIN"]+ assert [item["name"] for item in agent_grant.call_args.kwargs["deks"]] == [+ "PROTECTED_LOGIN",+ "PROTECTED_LOGIN.username",+ "PROTECTED_LOGIN.totp",+ ]diff --git a/tests/test_vault_cli.py b/tests/test_vault_cli.pyindex 9bf79d39a..4cabe847d 100644--- a/tests/test_vault_cli.py+++ b/tests/test_vault_cli.py@@ -8,11 +8,12 @@ from __future__ import annotationsimport argparseimport ioimport json+import shleximport shutilimport threadingimport timefrom pathlib import Path-from unittest.mock import Mock+from unittest.mock import MagicMock, Mockimport pytestfrom sqlalchemy import select@@ -157,10 +158,18 @@ def _set_protected_always_ask_grant(name: str, *, session_id: str | None = None,return _grant_from_request(conn, req, session_id=session_id)-def _set_tag_grant(names: list[str], *, tag: str = "crypto", session_id: str | None = None) -> dict:+def _set_tag_grant(+ names: list[str],+ *,+ tag: str = "crypto",+ session_id: str | None = None,+ fields: list[dict] | None = None,+) -> dict:with cli._open_vault_engine().begin() as conn:for name in names:- vault_service.create_secret(conn, name=name, protection="protected", tags=[tag], sealed=_sealed(name.lower()))+ vault_service.create_secret(+ conn, name=name, protection="protected", tags=[tag], sealed=_sealed(name.lower()), fields=fields+ )req = vault_service.create_access_request(conn,source_selector={"tags": [tag]},@@ -236,6 +245,28 @@ def test_parse_env_specs_rejects_duplicate_secret_alias():assert exc.value.code == "conflicting_env_alias"+def test_parse_env_specs_uppercases_only_field_name():+ assert cli._parse_env_specs(["lowerSecret.username"]) == {+ "lowerSecret_USERNAME": "lowerSecret.username"+ }+++def test_vault_skill_cli_examples_are_parser_backed():+ skill_path = Path(__file__).parents[1] / "skills" / "use-avibe-vault" / "SKILL.md"+ examples = [+ shlex.split(line.strip()[1:-1])+ for line in skill_path.read_text(encoding="utf-8").splitlines()+ if line.startswith("`vibe ") and line.rstrip().endswith("`")+ ]++ assert examples+ parser = cli.build_parser()+ for example in examples:+ assert example[0] == "vibe"+ parsed = parser.parse_args(example[1:])+ assert parsed.command == "vault"++def test_vault_parser_does_not_expose_plaintext_set_command():parser = cli.build_parser()with pytest.raises(SystemExit):@@ -353,6 +384,13 @@ def test_edit_policy_releases_resident_grant(capfd, monkeypatch):assert status == "expired"+def test_edit_cas_conflict_preserves_machine_readable_code(capfd, monkeypatch):+ _create_standard_secret("EDIT_CONFLICT")+ monkeypatch.setattr(vault_service, "update_secret_metadata", Mock(side_effect=vault_service.SecretConflictError("changed")))+ assert cli.cmd_vault_edit(_ns(name="EDIT_CONFLICT", description="new")) == 1+ assert json.loads(capfd.readouterr().err)["code"] == "secret_conflict"++def test_edit_metadata_json_rejects_secret_material(capfd):_create_standard_secret("EDIT_SAFE")@@ -363,6 +401,41 @@ def test_edit_metadata_json_rejects_secret_material(capfd):assert payload["code"] == "secret_material_rejected"+ ("metadata", "field_hint"),+ [+ ({"name": "LOGIN", "kind": "static", "default_field": "value", "fields": ["value"]}, False),+ ({"name": "LOGIN", "kind": "static", "default_field": "password", "fields": ["password"]}, True),+ ({"name": "LOGIN", "kind": "static", "default_field": "password", "fields": ["password", "username"]}, True),+ ({"name": "LOGIN", "kind": "static", "default_field": "value", "fields": ["value"], "fields_state": "corrupt"}, True),+ ({"name": "SIGNING", "kind": "keypair", "default_field": "value", "fields": ["value"]}, False),+ ],+)+def test_provision_field_hint_predicate_is_shared_across_callback_and_sync(metadata, field_hint, monkeypatch):+ from vibe import cli++ assert vault_service.has_named_field_shape(metadata) is field_hint+ row = {+ "id": "vrq_hint",+ "request_type": "provision",+ "status": "fulfilled",+ "secret_name": metadata["name"],+ "requester": json.dumps({}),+ "delivery": json.dumps({}),+ "provision_secret": metadata,+ }+ callback = vault_service._build_request_callback_message(row)+ engine = MagicMock()+ monkeypatch.setattr(vault_service, "get_secret_meta", lambda conn, name: metadata)+ sync = cli._vault_provision_success_usage(engine, metadata["name"])+ if field_hint:+ assert "Current fields:" in callback and f"{metadata['name']}.{metadata['default_field']}" in callback+ assert "Current fields:" in sync and f"{metadata['name']}.{metadata['default_field']}" in sync+ else:+ assert f"--env {metadata['name']} --" in callback and ".value" not in callback+ assert f"--env {metadata['name']} --" in sync and ".value" not in sync++def test_find_reports_value_free_capabilities(tmp_path, capfd, monkeypatch):_create_standard_secret("STANDARD_KEY")with cli._open_vault_engine().begin() as conn:@@ -405,6 +478,8 @@ def test_find_reports_value_free_capabilities(tmp_path, capfd, monkeypatch):"name": "STANDARD_KEY","kind": "static","protection": "standard",+ "default_field": "value",+ "fields": ["value"],"tags": [],"description": None,"policy": {},@@ -446,6 +521,46 @@ def test_find_filters_by_query_and_multiple_tags(capfd):assert payload["pagination"]["has_more"] is False[email protected]("command", ["find", "list"])[email protected]("query,expected_names", [+ ("password", ["LOGIN"]), ("username", ["LOGIN"]),+ ("LOGIN.password", ["LOGIN"]), ("LOGIN.username", ["LOGIN"]),+ ("hidden_ciphertext", []),+])+def test_value_free_search_matches_field_labels(capfd, command, query, expected_names):+ _create_standard_secret(+ "LOGIN", default_field="password",+ fields=[{"name": "username", "sealed": _sealed("hidden_ciphertext")}],+ )+ _create_standard_secret("UNRELATED")+ assert getattr(cli, f"cmd_vault_{command}")(_ns(query_filter=query)) == 0+ payload = json.loads(capfd.readouterr().out)+ assert [secret["name"] for secret in payload["secrets"]] == expected_names+ assert "hidden_ciphertext" not in json.dumps(payload["secrets"])++[email protected]("command", ["run", "inject"])[email protected]("selector", [{"tag": ["deploy"]}, {"skill": ["deploy"]}])+def test_corrupt_fields_are_visible_and_selector_delivery_fails_closed(tmp_path, capfd, monkeypatch, command, selector):+ from vibe import api++ _create_standard_secret("CORRUPT", tags=["deploy", "skill:deploy"])+ with cli._open_vault_engine().begin() as conn:+ conn.execute(vault_service.vault_secrets.update().where(vault_service.vault_secrets.c.name == "CORRUPT").values(fields='[{"name":"username"}]'))+ for lookup in (cli.cmd_vault_find, cli.cmd_vault_list):+ assert lookup(_ns()) == 0+ payload = json.loads(capfd.readouterr().out)+ assert payload["secrets"][0]["fields_state"] == "corrupt"+ assert payload["secrets"][0]["fields"] == ["value"]+ deliver = Mock()+ for mode in ("run", "inject"):+ monkeypatch.setattr(api, f"avault_deliver_{mode}", deliver)+ args = _ns(command_argv=["python3", "-c", "pass"], out=str(tmp_path / "unused.env"), format="dotenv", **selector)+ assert getattr(cli, f"cmd_vault_{command}")(args) == 1+ assert json.loads(capfd.readouterr().err)["code"] == "fields_corrupt"+ deliver.assert_not_called()++def test_tags_lists_normal_and_skill_tags(capfd):_create_standard_secret("OPENAI_PROD_KEY", tags=["openai", "prod", "skill:model-work"])_create_standard_secret("OPENAI_DEV_KEY", tags=["openai", "dev", "skill:model-work"])@@ -534,6 +649,14 @@ def test_access_request_cli_uses_caller_session(tmp_path, capfd, monkeypatch):assert payload["request"]["status"] == "pending"+def test_access_non_requestable_standard_secret_keeps_not_grantable_code(capfd):+ _create_standard_secret("STANDARD_KEY")+ assert cli.cmd_vault_access(_ns(name="STANDARD_KEY")) == 1+ assert json.loads(capfd.readouterr().err)["code"] == "not_grantable"+ with cli._open_vault_engine().connect() as conn:+ assert vault_service.list_requests(conn) == []++def test_access_request_cli_accepts_protected_static_request(capfd):with cli._open_vault_engine().begin() as conn:vault_service.create_secret(conn, name="PROTECTED_KEY", protection="protected", sealed=_sealed("protected"))@@ -546,6 +669,85 @@ def test_access_request_cli_accepts_protected_static_request(capfd):assert payload["request"]["card"]["protection"] == "protected"+ ("ref", "record"),+ [("LOGIN.password", "LOGIN"), ("LOGIN.username", "LOGIN.username")],+)+def test_access_record_ref_uses_value_free_record_metadata(capfd, monkeypatch, ref, record):+ with cli._open_vault_engine().begin() as conn:+ vault_service.create_secret(+ conn,+ name="LOGIN",+ protection="protected",+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ metadata = Mock(wraps=vault_service.get_secret_record_meta)+ monkeypatch.setattr(vault_service, "get_secret_record_meta", metadata)+ for getter in ("get_envelope", "get_protected_envelope"):+ monkeypatch.setattr(+ vault_service,+ getter,+ Mock(side_effect=AssertionError("access validation must not load an envelope")),+ )++ assert cli.cmd_vault_access(_ns(name=ref)) == 0+ payload = json.loads(capfd.readouterr().out)++ metadata.assert_called_once()+ assert metadata.call_args.args[1] == ref+ assert payload["request"]["secret_name"] == "LOGIN"+ assert payload["request"]["delivery"]["record"] == record++[email protected]("command", ["run", "fetch", "inject", "access"])+ ("ref", "expected_code"),+ [+ ("LOGIN.missing", "field_not_found"),+ ("LOGIN.UPPER", "invalid_field_name"),+ ("LOGIN.bad-name", "invalid_field_name"),+ ("SIGNING.value", "fields_not_supported"),+ ],+)+def test_record_ref_errors_are_structured_before_delivery(+ tmp_path, capfd, monkeypatch, command, ref, expected_code+):+ from vibe import api++ _create_standard_secret(+ "LOGIN",+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ _create_standard_secret("SIGNING", kind="keypair", signer_kind="local")+ deliver = Mock()+ for operation in ("run", "fetch", "inject"):+ monkeypatch.setattr(api, f"avault_deliver_{operation}", deliver)+ monkeypatch.setattr(api, f"avault_agent_deliver_{operation}", deliver)+ args = _ns(+ name=ref,+ auth=ref,+ env=[ref],+ command_argv=["python3", "-c", "pass"],+ url="https://api.github.com/user",+ out=str(tmp_path / "login.env"),+ format="dotenv",+ )++ assert getattr(cli, f"cmd_vault_{command}")(args) == 1+ payload = json.loads(capfd.readouterr().err)++ assert payload["code"] == expected_code+ assert payload["help_command"] == f"vibe vault {command} --help"+ if expected_code == "field_not_found":+ assert "password, username" in payload["error"]+ deliver.assert_not_called()+ with cli._open_vault_engine().connect() as conn:+ assert vault_service.list_requests(conn) == []++def test_sign_cli_standard_key_returns_inline_signature_without_request(capfd, monkeypatch):from vibe import api@@ -735,7 +937,7 @@ def test_run_calls_avault_with_env_mapping_and_records_delivery(tmp_path, capfd,code = cli.cmd_vault_run(_ns(env=["LOCAL_NAME=SRC_KEY"], command_argv=["python3", "-c", "pass"]))assert code == 0deliver.assert_called_once_with(- [{"name": "SRC_KEY", "env": "LOCAL_NAME", "envelope": _sealed("run")}],+ [{"name": "SRC_KEY", "env": "LOCAL_NAME", "envelope": _sealed("run"), "tier": "standard"}],["python3", "-c", "pass"],)cli.cmd_vault_list(_ns())@@ -744,6 +946,109 @@ def test_run_calls_avault_with_env_mapping_and_records_delivery(tmp_path, capfd,assert secret["last_used_at"] is not None+def test_run_canonicalizes_default_alias_and_delivers_extra_field(tmp_path, capfd, monkeypatch):+ from vibe import api++ _create_standard_secret(+ "GITHUB_LOGIN",+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ deliver = Mock(return_value=0)+ monkeypatch.setattr(api, "avault_deliver_run", deliver)++ assert cli.cmd_vault_run(+ _ns(+ env=["GITHUB_LOGIN.password", "GITHUB_LOGIN.username"],+ command_argv=["python3", "-c", "pass"],+ )+ ) == 0++ assert deliver.call_args.args[0] == [+ {+ "name": "GITHUB_LOGIN",+ "env": "GITHUB_LOGIN_PASSWORD",+ "envelope": _sealed("password"),+ "tier": "standard",+ },+ {+ "name": "GITHUB_LOGIN.username",+ "env": "GITHUB_LOGIN_USERNAME",+ "envelope": _sealed("username"),+ "tier": "standard",+ },+ ]+++def test_completed_run_audits_snapshot_fields_removed_or_renamed_during_child(capfd, monkeypatch):+ from vibe import api++ _create_standard_secret("LOGIN", default_field="password", fields=[{"name": "username", "sealed": _sealed("user")}])+ _create_standard_secret("OTHER", fields=[{"name": "token", "sealed": _sealed("token")}])++ def finish_run(secrets, command):+ assert {entry["name"] for entry in secrets} == {"LOGIN", "LOGIN.username", "OTHER.token"}+ with cli._open_vault_engine().begin() as conn:+ vault_service.remove_secret_field(conn, "LOGIN", "username")+ vault_service.update_secret_metadata(conn, "LOGIN", default_field="credential")+ return {"exit_code": 0, "delivered": True}++ monkeypatch.setattr(api, "avault_deliver_run", finish_run)+ assert cli.cmd_vault_run(_ns(env=["LOGIN", "LOGIN.username", "OTHER.token"], command_argv=["python3", "-c", "pass"])) == 0+ with cli._open_vault_engine().connect() as conn:+ assert vault_service.get_secret_meta(conn, "LOGIN")["use_count"] == 1+ assert vault_service.get_secret_meta(conn, "OTHER")["use_count"] == 1+ delivered = {+ event["secret_name"]: json.loads(event["delivery"])["fields"]+ for event in vault_service.list_audit(conn)+ if event["event"] == "delivered"+ }+ assert delivered == {"LOGIN": ["password", "username"], "OTHER": ["token"]}+++def test_run_rejects_alias_collision_after_record_canonicalization(capfd, monkeypatch):+ from vibe import api++ _create_standard_secret(+ "GITHUB_LOGIN",+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ deliver = Mock()+ monkeypatch.setattr(api, "avault_deliver_run", deliver)++ code = cli.cmd_vault_run(+ _ns(+ env=["PASSWORD=GITHUB_LOGIN", "EXPLICIT=GITHUB_LOGIN.password"],+ command_argv=["python3", "-c", "pass"],+ )+ )+ payload = json.loads(capfd.readouterr().err)++ assert code == 1+ assert payload["code"] == "conflicting_env_alias"+ deliver.assert_not_called()+++def test_run_dedupes_default_refs_with_the_same_env_alias(capfd, monkeypatch):+ from vibe import api++ _create_standard_secret("LOGIN", default_field="password")+ deliver = Mock(return_value=0)+ monkeypatch.setattr(api, "avault_deliver_run", deliver)++ assert cli.cmd_vault_run(+ _ns(+ env=["PASSWORD=LOGIN,PASSWORD=LOGIN.password"],+ command_argv=["python3", "-c", "pass"],+ )+ ) == 0+ assert deliver.call_args.args[0] == [+ {"name": "LOGIN", "env": "PASSWORD", "envelope": _sealed(), "tier": "standard"}+ ]++def test_run_expands_tags_and_skill_tags_as_union(capfd, monkeypatch):from vibe import api@@ -760,6 +1065,40 @@ def test_run_expands_tags_and_skill_tags_as_union(capfd, monkeypatch):assert delivered == {"A_KEY": "A_KEY", "B_KEY": "B_KEY", "C_KEY": "C_KEY"}[email protected]("selector", [{"tag": ["deploy"]}, {"skill": ["release"]}])+def test_run_tag_and_skill_select_every_field(capfd, monkeypatch, selector):+ from vibe import api++ _create_standard_secret(+ "DEPLOY_LOGIN",+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ tags=["deploy", "skill:release"],+ )+ deliver = Mock(return_value=0)+ monkeypatch.setattr(api, "avault_deliver_run", deliver)++ assert cli.cmd_vault_run(+ _ns(**selector, command_argv=["python3", "-c", "pass"])+ ) == 0++ assert deliver.call_args.args[0] == [+ {+ "name": "DEPLOY_LOGIN",+ "env": "DEPLOY_LOGIN",+ "envelope": _sealed("password"),+ "tier": "standard",+ },+ {+ "name": "DEPLOY_LOGIN.username",+ "env": "DEPLOY_LOGIN_USERNAME",+ "envelope": _sealed("username"),+ "tier": "standard",+ },+ ]++def test_run_skill_selects_skill_link_mirror_tag(monkeypatch):from vibe import api@@ -772,7 +1111,9 @@ def test_run_skill_selects_skill_link_mirror_tag(monkeypatch):code = cli.cmd_vault_run(_ns(skill=["deploy"], command_argv=["python3", "-c", "pass"]))assert code == 0- assert deliver.call_args.args[0] == [{"name": "LINKED_KEY", "env": "LINKED_KEY", "envelope": _sealed("linked")}]+ assert deliver.call_args.args[0] == [+ {"name": "LINKED_KEY", "env": "LINKED_KEY", "envelope": _sealed("linked"), "tier": "standard"}+ ]@pytest.mark.parametrize("selector", [{"tag": ["missing"]}, {"skill": ["missing"]}])@@ -1130,7 +1471,7 @@ def test_inject_resolver_uses_session_bound_protected_grant(tmp_path):resolved_grant, one_shot_grants, secrets = cli._resolve_vault_inject_delivery(engine,- ["PROTECTED_KEY"],+ {"PROTECTED_KEY": "PROTECTED_KEY"},path=str(tmp_path / "out.env"),fmt="dotenv",args=_ns(session_id="ses_cli"),@@ -1138,7 +1479,9 @@ def test_inject_resolver_uses_session_bound_protected_grant(tmp_path):assert resolved_grant["id"] == grant["id"]assert one_shot_grants == []- assert secrets == [{"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected")}]+ assert secrets == [+ {"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected"), "tier": "protected"}+ ]def test_run_fast_path_reserves_protected_always_ask_grant(tmp_path, capfd, monkeypatch):@@ -1305,8 +1648,8 @@ def test_run_reuses_multi_secret_standard_one_shot_grant(tmp_path, capfd, monkeyassert code == 0deliver.assert_called_once_with([- {"name": "ASK_A", "env": "A", "envelope": _sealed("ask_a")},- {"name": "ASK_B", "env": "B", "envelope": _sealed("ask_b")},+ {"name": "ASK_A", "env": "A", "envelope": _sealed("ask_a"), "tier": "standard"},+ {"name": "ASK_B", "env": "B", "envelope": _sealed("ask_b"), "tier": "standard"},],["python3", "-c", "pass"],)@@ -1369,9 +1712,9 @@ def test_run_tag_reuses_standard_one_shot_subset_with_normal_secrets(tmp_path, cassert code == 0deliver.assert_called_once_with([- {"name": "ASK_A", "env": "ASK_A", "envelope": _sealed("ask_a")},- {"name": "ASK_B", "env": "ASK_B", "envelope": _sealed("ask_b")},- {"name": "NORMAL_DEPLOY", "env": "NORMAL_DEPLOY", "envelope": _sealed("normal")},+ {"name": "ASK_A", "env": "ASK_A", "envelope": _sealed("ask_a"), "tier": "standard"},+ {"name": "ASK_B", "env": "ASK_B", "envelope": _sealed("ask_b"), "tier": "standard"},+ {"name": "NORMAL_DEPLOY", "env": "NORMAL_DEPLOY", "envelope": _sealed("normal"), "tier": "standard"},],["python3", "-c", "pass"],)@@ -1395,8 +1738,8 @@ def test_inject_reuses_multi_secret_standard_one_shot_grant(tmp_path, capfd, monstr(out),"dotenv",[- {"name": "ASK_A", "key": "ASK_A", "envelope": _sealed("ask_a")},- {"name": "ASK_B", "key": "ASK_B", "envelope": _sealed("ask_b")},+ {"name": "ASK_A", "key": "ASK_A", "envelope": _sealed("ask_a"), "tier": "standard"},+ {"name": "ASK_B", "key": "ASK_B", "envelope": _sealed("ask_b"), "tier": "standard"},],)with cli._open_vault_engine().connect() as conn:@@ -1441,7 +1784,7 @@ def test_run_consumes_standard_always_ask_grant_after_delivery(tmp_path, capfd,assert code == 0deliver.assert_called_once_with(- [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key")}],+ [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key"), "tier": "standard"}],["python3", "-c", "pass"],)with cli._open_vault_engine().connect() as conn:@@ -1460,7 +1803,7 @@ def test_run_consumes_standard_always_ask_grant_when_child_exits_70(tmp_path, caassert code == 70deliver.assert_called_once_with(- [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key")}],+ [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key"), "tier": "standard"}],["python3", "-c", "raise SystemExit(70)"],)with cli._open_vault_engine().connect() as conn:@@ -1574,7 +1917,11 @@ def test_inject_uses_resolved_output_path_for_standard_always_ask_delivery(tmp_passert code == 0assert payload["path"] == expected- deliver.assert_called_once_with(expected, "dotenv", [{"name": "ASK_KEY", "key": "ASK_KEY", "envelope": _sealed("ask_key")}])+ deliver.assert_called_once_with(+ expected,+ "dotenv",+ [{"name": "ASK_KEY", "key": "ASK_KEY", "envelope": _sealed("ask_key"), "tier": "standard"}],+ )with cli._open_vault_engine().connect() as conn:status = conn.execute(vault_grants.select().where(vault_grants.c.id == grant["id"])).mappings().one()["status"]assert status == "expired"@@ -1918,17 +2265,24 @@ def test_run_expires_grant_when_agent_cache_is_missing(capfd, monkeypatch):assert requests[0]["card"]["grant_options"][0]["purpose"] == "run"-def test_run_reopens_one_selector_set_when_agent_cache_is_missing(capfd, monkeypatch):[email protected]("field_refs", [False, True])+def test_run_reopens_one_selector_set_when_agent_cache_is_missing(capfd, monkeypatch, field_refs):from vibe import api- grant = _set_tag_grant(["A_KEY", "B_KEY"])- monkeypatch.setattr(api, "avault_agent_deliver_run", Mock(side_effect=api.AvaultError("grant is missing or expired")))+ grant = _set_tag_grant(+ ["A_KEY", "B_KEY"],+ fields=[{"name": "username", "sealed": _sealed("username")}] if field_refs else None,+ )+ refs = ["A_KEY.username", "B_KEY.username"] if field_refs else ["A_KEY", "B_KEY"]+ deliver = Mock(side_effect=api.AvaultError("grant is missing or expired"))+ monkeypatch.setattr(api, "avault_agent_deliver_run", deliver)- code = cli.cmd_vault_run(_ns(env=["A_KEY", "B_KEY"], command_argv=["python3", "-c", "pass"]))+ code = cli.cmd_vault_run(_ns(env=refs, command_argv=["python3", "-c", "pass"]))captured = capfd.readouterr()assert code == 1assert json.loads(captured.err)["code"] == "approval_required"+ assert [item["name"] for item in deliver.call_args.kwargs["secrets"]] == refswith cli._open_vault_engine().connect() as conn:status = conn.execute(vault_grants.select().where(vault_grants.c.id == grant["id"])).mappings().one()["status"]requests = vault_service.list_requests(conn, status="pending")@@ -1936,9 +2290,12 @@ def test_run_reopens_one_selector_set_when_agent_cache_is_missing(capfd, monkeypassert len(requests) == 1assert requests[0]["secret_name"] is Noneassert requests[0]["delivery"]["protected_secret_names"] == ["A_KEY", "B_KEY"]- assert requests[0]["delivery"]["source_selector"] == {"env": ["A_KEY", "B_KEY"]}+ expected_selector = {+ "env": ["A_KEY_USERNAME=A_KEY.username", "B_KEY_USERNAME=B_KEY.username"] if field_refs else refs+ }+ assert requests[0]["delivery"]["source_selector"] == expected_selectoroption = requests[0]["card"]["grant_options"][0]- assert option["source_selector"] == {"env": ["A_KEY", "B_KEY"]}+ assert option["source_selector"] == expected_selectorassert option["member_snapshot"] == ["A_KEY", "B_KEY"]@@ -2054,7 +2411,7 @@ def test_inject_resolver_publishes_pending_request_when_approval_required(tmp_pawith pytest.raises(cli.TaskCliError) as exc_info:cli._resolve_vault_inject_delivery(cli._open_vault_engine(),- ["PROTECTED_KEY"],+ {"PROTECTED_KEY": "PROTECTED_KEY"},path=str(tmp_path / "out.env"),fmt="dotenv",args=_ns(session_id="ses_cli"),@@ -2240,6 +2597,40 @@ def test_request_for_existing_secret_returns_fulfilled(tmp_path, capfd, monkeypaassert json.loads(capfd.readouterr().out)["status"] == "fulfilled"[email protected]("already_exists", [False, True])[email protected]("with_spec", [False, True])+def test_field_provision_success_hints_use_current_subset(capfd, monkeypatch, already_exists, with_spec):+ def provide_subset():+ _create_standard_secret(+ "LOGIN", default_field="credential", sealed=_sealed("do-not-expose"),+ fields=[{"name": "username", "sealed": _sealed("hidden-user")}],+ )++ def complete_during_wait(request_id, **_kwargs):+ provide_subset()+ with cli._open_vault_engine().connect() as conn:+ return vault_service.get_request(conn, request_id)++ wait = Mock(side_effect=complete_during_wait)+ monkeypatch.setattr(cli, "_wait_for_provision", wait)+ if already_exists:+ provide_subset()+ request_args = ["vault", "request", "LOGIN", "--wait", "30"]+ if with_spec:+ request_args.extend(["--spec-json", '{"fields":["username","password","totp"],"default_field":"password"}'])+ args = cli.build_parser().parse_args(request_args)+ assert cli.cmd_vault_request(args) == 0+ payload = json.loads(capfd.readouterr().out)+ assert payload["status"] == "fulfilled"+ assert wait.call_count == (0 if already_exists else 1)+ message = payload["message"]+ assert "credential" in message and "username" in message+ assert "LOGIN.credential" in message+ assert "vibe vault run --env LOGIN.username" in message+ assert "password" not in message and "totp" not in message+ assert "do-not-expose" not in message and "hidden-user" not in message++def test_request_wait_outputs_fulfilled_request(capfd, monkeypatch):def wait_mock(request_id, *, timeout, poll_interval=2.0):with cli._open_vault_engine().begin() as conn:diff --git a/tests/test_vault_export_inject.py b/tests/test_vault_export_inject.pyindex 2ab9ed391..864e042d3 100644--- a/tests/test_vault_export_inject.py+++ b/tests/test_vault_export_inject.py@@ -8,7 +8,9 @@ import jsonimport pytestfrom storage import vault_service+from storage.models import vault_grantsfrom storage.vault_crypto import Sealed+from sqlalchemy import selectfrom vibe import cli@@ -37,9 +39,25 @@ def _sealed(suffix: str = "1") -> Sealed:return Sealed(ciphertext=f"ct-{suffix}", nonce=f"n-{suffix}", wrap_meta=f"wm-{suffix}")-def _create_standard_secret(name: str, *, sealed: Sealed | None = None):+def _create_standard_secret(+ name: str,+ *,+ sealed: Sealed | None = None,+ default_field: str | None = None,+ fields: list[dict] | None = None,+ tags: list[str] | None = None,+ policy: dict | None = None,+):with cli._open_vault_engine().begin() as conn:- vault_service.create_secret(conn, name=name, sealed=sealed or _sealed(name.lower()))+ vault_service.create_secret(+ conn,+ name=name,+ sealed=sealed or _sealed(name.lower()),+ default_field=default_field,+ fields=fields,+ tags=tags,+ policy=policy,+ )def _grant_from_request(conn, request: dict, *, session_id: str | None = None) -> dict:@@ -96,8 +114,8 @@ def test_inject_calls_avault_and_records_delivery(tmp_path, capfd, monkeypatch,str(out),fmt,[- {"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a")},- {"name": "B_KEY", "key": "B_KEY", "envelope": _sealed("b")},+ {"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a"), "tier": "standard"},+ {"name": "B_KEY", "key": "B_KEY", "envelope": _sealed("b"), "tier": "standard"},],)cli.cmd_vault_list(_ns())@@ -106,6 +124,255 @@ def test_inject_calls_avault_and_records_delivery(tmp_path, capfd, monkeypatch,assert secrets["B_KEY"]["use_count"] == 1+def test_inject_canonicalizes_default_alias_and_maps_extra_field_key(tmp_path, capfd, monkeypatch):+ from unittest.mock import Mock++ from vibe import api++ _create_standard_secret(+ "LOGIN",+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ inject = Mock(return_value=None)+ monkeypatch.setattr(api, "avault_deliver_inject", inject)+ out = tmp_path / "login.env"++ assert cli.cmd_vault_inject(+ _ns(keys="LOGIN.password,LOGIN.username", out=str(out), format="dotenv")+ ) == 0+ capfd.readouterr()++ inject.assert_called_once_with(+ str(out),+ "dotenv",+ [+ {+ "name": "LOGIN",+ "key": "LOGIN_PASSWORD",+ "envelope": _sealed("password"),+ "tier": "standard",+ },+ {+ "name": "LOGIN.username",+ "key": "LOGIN_USERNAME",+ "envelope": _sealed("username"),+ "tier": "standard",+ },+ ],+ )++[email protected]("selector", [{"tag": ["deploy"]}, {"skill": ["release"]}])+def test_inject_accepts_tag_and_skill_selectors_for_all_fields(tmp_path, capfd, monkeypatch, selector):+ from unittest.mock import Mock++ from vibe import api++ _create_standard_secret(+ "DEPLOY_LOGIN",+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ tags=["deploy", "skill:release"],+ )+ inject = Mock(return_value=None)+ monkeypatch.setattr(api, "avault_deliver_inject", inject)+ out = tmp_path / "deploy.env"++ assert cli.cmd_vault_inject(+ _ns(**selector, out=str(out), format="dotenv")+ ) == 0+ capfd.readouterr()++ assert inject.call_args.args[2] == [+ {+ "name": "DEPLOY_LOGIN",+ "key": "DEPLOY_LOGIN",+ "envelope": _sealed("password"),+ "tier": "standard",+ },+ {+ "name": "DEPLOY_LOGIN.username",+ "key": "DEPLOY_LOGIN_USERNAME",+ "envelope": _sealed("username"),+ "tier": "standard",+ },+ ]+++def test_inject_rejects_selector_record_conflict_before_avault(tmp_path, capfd, monkeypatch):+ from unittest.mock import Mock++ from vibe import api++ _create_standard_secret(+ "LOGIN",+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ inject = Mock()+ monkeypatch.setattr(api, "avault_deliver_inject", inject)++ code = cli.cmd_vault_inject(+ _ns(+ env=["A=LOGIN", "B=LOGIN.password"],+ out=str(tmp_path / "conflict.env"),+ format="dotenv",+ )+ )+ payload = json.loads(capfd.readouterr().err)++ assert code == 1+ assert payload["code"] == "conflicting_env_alias"+ inject.assert_not_called()++[email protected]("protection", ["standard", "protected"])+ "selector",+ [+ {"keys": "ASK_LOGIN.password,ASK_LOGIN.username"},+ {"env": ["ASK_LOGIN.password", "ASK_LOGIN.username"]},+ ],+)+def test_inject_one_shot_field_pair_records_one_secret_delivery(+ tmp_path, capfd, monkeypatch, protection, selector+):+ from unittest.mock import Mock++ from vibe import api++ with cli._open_vault_engine().begin() as conn:+ vault_service.create_secret(+ conn,+ name="ASK_LOGIN",+ protection=protection,+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ policy={"always_ask": True},+ )+ request = vault_service.create_access_request(+ conn,+ "ASK_LOGIN",+ purpose="inject",+ requester={"source": "cli"},+ delivery={"mode": "inject"},+ )+ grant = _grant_from_request(conn, request)++ inject = Mock(return_value=None)+ monkeypatch.setattr(+ api,+ "avault_agent_deliver_inject" if protection == "protected" else "avault_deliver_inject",+ inject,+ )+ out = tmp_path / "ask-login.env"++ assert cli.cmd_vault_inject(+ _ns(**selector, out=str(out), format="dotenv")+ ) == 0+ capfd.readouterr()++ inject.assert_called_once()+ records = inject.call_args.kwargs["secrets"] if protection == "protected" else inject.call_args.args[2]+ assert records == [+ {+ "name": "ASK_LOGIN",+ "key": "ASK_LOGIN_PASSWORD",+ "envelope": _sealed("password"),+ "tier": protection,+ },+ {+ "name": "ASK_LOGIN.username",+ "key": "ASK_LOGIN_USERNAME",+ "envelope": _sealed("username"),+ "tier": protection,+ },+ ]+ with cli._open_vault_engine().connect() as conn:+ status = conn.execute(+ select(vault_grants.c.status).where(vault_grants.c.id == grant["id"])+ ).scalar_one()+ meta = vault_service.get_secret_meta(conn, "ASK_LOGIN")+ audits = vault_service.list_audit(conn, secret_name="ASK_LOGIN")+ assert status == "expired"+ assert meta["use_count"] == 1+ delivered = [row for row in audits if row["event"] == "delivered"]+ assert json.loads(delivered[-1]["delivery"])["fields"] == ["password", "username"]++[email protected]("protection", ["standard", "protected"])+def test_inject_tag_approval_covers_secret_members_and_delivers_all_fields(+ tmp_path, capfd, monkeypatch, protection+):+ from unittest.mock import Mock++ from vibe import api++ with cli._open_vault_engine().begin() as conn:+ vault_service.create_secret(+ conn,+ name="LOGIN",+ protection=protection,+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ tags=["deploy"],+ policy={"always_ask": True} if protection == "standard" else {},+ )+ vault_service.create_secret(+ conn,+ name="OTHER",+ protection=protection,+ sealed=_sealed("other"),+ tags=["deploy"],+ )+ inject = Mock(return_value=None)+ monkeypatch.setattr(+ api,+ "avault_agent_deliver_inject" if protection == "protected" else "avault_deliver_inject",+ inject,+ )+ args = _ns(tag=["deploy"], out=str(tmp_path / "deploy.env"), format="dotenv")++ assert cli.cmd_vault_inject(args) == 1+ assert json.loads(capfd.readouterr().err)["code"] == "approval_required"+ inject.assert_not_called()+ with cli._open_vault_engine().begin() as conn:+ requests = vault_service.list_requests(conn, status="pending")+ assert len(requests) == 1+ request = requests[0]+ assert request["card"]["grant_options"][0]["member_snapshot"] == (+ ["LOGIN", "OTHER"] if protection == "protected" else ["LOGIN"]+ )+ grant = _grant_from_request(conn, request)++ assert cli.cmd_vault_inject(args) == 0+ capfd.readouterr()+ records = inject.call_args.kwargs["secrets"] if protection == "protected" else inject.call_args.args[2]+ assert [(item["name"], item["key"], item["tier"]) for item in records] == [+ ("LOGIN", "LOGIN", protection),+ ("LOGIN.username", "LOGIN_USERNAME", protection),+ ("OTHER", "OTHER", protection),+ ]+ if protection == "protected":+ inject.side_effect = api.AvaultError("grant is missing or expired")+ assert cli.cmd_vault_inject(args) == 1+ assert json.loads(capfd.readouterr().err)["code"] == "approval_required"+ with cli._open_vault_engine().connect() as conn:+ requests = vault_service.list_requests(conn, status="pending")+ status = conn.execute(+ select(vault_grants.c.status).where(vault_grants.c.id == grant["id"])+ ).scalar_one()+ assert status == "expired"+ assert len(requests) == 1+ assert requests[0]["card"]["grant_options"][0]["member_snapshot"] == ["LOGIN", "OTHER"]+ assert requests[0]["delivery"]["protected_secret_names"] == ["LOGIN", "OTHER"]++def test_inject_rejects_keypair_before_avault_delivery(tmp_path, capfd, monkeypatch):from unittest.mock import Mock@@ -141,7 +408,14 @@ def test_inject_uses_agent_delivery_for_protected_grant(tmp_path, capfd, monkeypgrant_id=grant["id"],path=str(out),fmt="dotenv",- secrets=[{"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected_key")}],+ secrets=[+ {+ "name": "PROTECTED_KEY",+ "key": "PROTECTED_KEY",+ "envelope": _sealed("protected_key"),+ "tier": "protected",+ }+ ],)assert "value" not in repr(inject.call_args.kwargs)@@ -165,7 +439,14 @@ def test_inject_resolves_protected_relative_output_in_caller_cwd(tmp_path, capfdgrant_id=grant["id"],path=expected,fmt="dotenv",- secrets=[{"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected_key")}],+ secrets=[+ {+ "name": "PROTECTED_KEY",+ "key": "PROTECTED_KEY",+ "envelope": _sealed("protected_key"),+ "tier": "protected",+ }+ ],)assert payload["path"] == expected@@ -246,7 +527,11 @@ def test_inject_dedupes_repeated_keys(tmp_path, capfd, monkeypatch):out = tmp_path / "dup.env"assert cli.cmd_vault_inject(_ns(keys="A_KEY,A_KEY", out=str(out), format="dotenv")) == 0assert json.loads(capfd.readouterr().out)["keys"] == ["A_KEY"]- inject.assert_called_once_with(str(out), "dotenv", [{"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a")}])+ inject.assert_called_once_with(+ str(out),+ "dotenv",+ [{"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a"), "tier": "standard"}],+ )cli.cmd_vault_list(_ns())assert json.loads(capfd.readouterr().out)["secrets"][0]["use_count"] == 1diff --git a/tests/test_vault_fetch.py b/tests/test_vault_fetch.pyindex 42d4c5043..26af958ec 100644--- a/tests/test_vault_fetch.py+++ b/tests/test_vault_fetch.py@@ -54,6 +54,9 @@ def _create_standard_secret(allow_host: list[str] | None = None,auth_header: str | None = None,auth_query: str | None = None,+ sealed: Sealed | None = None,+ default_field: str | None = None,+ fields: list[dict] | None = None,) -> None:policy: dict = {}if allow_host:@@ -66,8 +69,10 @@ def _create_standard_secret(vault_service.create_secret(conn,name=name,- sealed=_sealed(name.lower()),+ sealed=sealed or _sealed(name.lower()),policy=policy or None,+ default_field=default_field,+ fields=fields,)@@ -171,6 +176,49 @@ def test_fetch_passes_bearer_request_to_avault_and_writes_stdout(tmp_path, capfdassert vault_service.get_secret_meta(conn, "GH_PAT")["use_count"] == 1+ ("auth", "expected_name", "expected_sealed", "expected_field"),+ [+ ("GH_LOGIN.password", "GH_LOGIN", _sealed("password"), "password"),+ ("GH_LOGIN.username", "GH_LOGIN.username", _sealed("username"), "username"),+ ],+)+def test_fetch_canonicalizes_record_name_and_uses_secret_policy(+ capfd,+ monkeypatch,+ auth,+ expected_name,+ expected_sealed,+ expected_field,+):+ from unittest.mock import Mock++ from vibe import api++ _create_standard_secret(+ "GH_LOGIN",+ allow_host=["api.github.com"],+ sealed=_sealed("password"),+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})+ monkeypatch.setattr(api, "avault_deliver_fetch", fetch)++ assert cli.cmd_vault_fetch(_ns(auth=auth, url="https://api.github.com/user")) == 0+ capfd.readouterr()++ name, sealed, request = fetch.call_args.args+ assert name == expected_name+ assert sealed == expected_sealed+ assert request["allowed_hosts"] == ["api.github.com"]+ with cli._open_vault_engine().connect() as conn:+ assert vault_service.get_secret_meta(conn, "GH_LOGIN")["use_count"] == 1+ audit_rows = vault_service.list_audit(conn, secret_name="GH_LOGIN")+ proxied = [row for row in audit_rows if row["event"] == "proxied"]+ assert json.loads(proxied[-1]["delivery"])["field"] == expected_field++def test_fetch_rejects_keypair_before_avault_delivery(capfd, monkeypatch):from unittest.mock import Mockdiff --git a/tests/test_vault_request_callbacks.py b/tests/test_vault_request_callbacks.pyindex c028109b3..b6a36132e 100644--- a/tests/test_vault_request_callbacks.py+++ b/tests/test_vault_request_callbacks.py@@ -18,7 +18,7 @@ from modules.im import MessageContextfrom storage import vault_service as vsfrom storage import messages_servicefrom storage.db import create_sqlite_engine-from storage.models import metadata, vault_requests+from storage.models import metadata, vault_requests, vault_secretsfrom storage.vault_crypto import Sealed@@ -128,6 +128,53 @@ def test_provision_fulfill_arms_callback(vault):assert plan is not None and "provided" in plan.message.lower()[email protected]("with_spec", [False, True])+def test_field_provision_callback_reports_current_value_free_fields(vault, with_spec):+ with vault.begin() as conn:+ req = vs.create_provision_request(+ conn, "LOGIN", requester={"session_id": "ses_p"},+ spec={"fields": ["username", "password", "totp"], "default_field": "password"} if with_spec else None,+ )+ vs.create_secret(+ conn, name="LOGIN", default_field="password", sealed=_sealed("do-not-show-default"),+ fields=[{"name": "username", "sealed": _sealed("do-not-show-extra")}],+ )+ vs.update_secret_metadata(conn, "LOGIN", default_field="credential")+ pending = next(row for row in vs.list_pending_request_callbacks(conn) if row["id"] == req["id"])+ plan = vs.resolve_request_callback(pending)+ assert plan is not None+ assert "credential" in plan.message and "username" in plan.message+ assert "LOGIN.username" in plan.message or "LOGIN.credential" in plan.message+ assert "--env" in plan.message+ assert "totp" not in plan.message and "password" not in plan.message+ assert "do-not-show" not in plan.message+ assert "ciphertext" not in plan.message+++ ("default_field", "corrupt", "expected"),+ [("password", False, "LOGIN.password"), ("value", True, "corrupt")],+)+def test_async_field_provision_callback_attaches_single_custom_and_corrupt_shapes(+ vault, default_field, corrupt, expected,+):+ with vault.begin() as conn:+ req = vs.create_provision_request(conn, "LOGIN", requester={"session_id": "ses_p"})+ vs.create_secret(conn, name="LOGIN", default_field=default_field, sealed=_sealed("do-not-show"))+ if corrupt:+ conn.execute(+ vault_secrets.update()+ .where(vault_secrets.c.name == "LOGIN")+ .values(fields="{malformed")+ )+ pending = next(row for row in vs.list_pending_request_callbacks(conn) if row["id"] == req["id"])+ plan = vs.resolve_request_callback(pending)+ assert plan is not None+ assert expected in plan.message+ assert "Current fields:" in plan.message+ assert "do-not-show" not in plan.message++def test_expiry_arms_callback(vault):past = (datetime.now(timezone.utc) - timedelta(minutes=1)).isoformat()with vault.begin() as conn:diff --git a/tests/test_vault_rest.py b/tests/test_vault_rest.pyindex 85c41086f..f520b9f33 100644--- a/tests/test_vault_rest.py+++ b/tests/test_vault_rest.py@@ -550,3 +550,77 @@ def test_rest_sign_errors_are_stable(monkeypatch):)assert not_key.status_code == 409assert not_key.get_json()["code"] == "not_signing_key"+++def test_rest_field_put_delete_routes_use_canonical_record_name(monkeypatch):+ seal = Mock(side_effect=[_sealed("default"), _sealed("username"), _sealed("newer")])+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)+ api.create_vault_secret(+ {+ "name": "REST_LOGIN",+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "default"},+ }+ )+ client = app.test_client()+ headers = csrf_headers(client)++ put = client.put(+ "/api/vault/secrets/REST_LOGIN/fields/username",+ json={+ "record": "REST_LOGIN.username",+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "username"},+ },+ headers=headers,+ )+ assert put.status_code == 200+ assert put.get_json()["secret"]["fields"] == ["value", "username"]+ assert seal.call_args_list[1].args[0] == "REST_LOGIN.username"++ old_version = put.get_json()["secret"]["updated_at"]+ newer = api.update_vault_secret_field("REST_LOGIN", "username", {+ "record": "REST_LOGIN.username",+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "newer"},+ })+ stale = client.delete(+ "/api/vault/secrets/REST_LOGIN/fields/username",+ json={"expected_updated_at": old_version}, headers=headers,+ )+ assert stale.status_code == 409+ assert stale.get_json()["code"] == "secret_conflict"+ assert api.get_vault_secrets()["secrets"][0]["fields"] == ["value", "username"]+ removed = client.delete(+ "/api/vault/secrets/REST_LOGIN/fields/username",+ json={"expected_updated_at": newer["secret"]["updated_at"]}, headers=headers,+ )+ assert removed.status_code == 200+ assert removed.get_json()["secret"]["fields"] == ["value"]+++def test_rest_field_routes_reject_plaintext_and_default_delete(monkeypatch):+ seal = Mock(return_value=_sealed())+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)+ api.create_vault_secret(+ {+ "name": "REST_LOGIN",+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "default"},+ }+ )+ client = app.test_client()+ headers = csrf_headers(client)++ rejected = client.put(+ "/api/vault/secrets/REST_LOGIN/fields/password",+ json={+ "record": "REST_LOGIN.password",+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "password"},+ "nested": {"value": "plaintext"},+ },+ headers=headers,+ )+ assert rejected.status_code == 400+ assert rejected.get_json()["code"] == "plaintext_value_rejected"+ seal.assert_called_once()++ default_delete = client.delete("/api/vault/secrets/REST_LOGIN/fields/value", headers=headers)+ assert default_delete.status_code == 409+ assert default_delete.get_json()["code"] == "invalid_request"diff --git a/tests/test_vault_schema.py b/tests/test_vault_schema.pyindex 0ae88b123..291d1ac1f 100644--- a/tests/test_vault_schema.py+++ b/tests/test_vault_schema.py@@ -1,9 +1,17 @@from __future__ import annotations-from sqlalchemy import text+import json+import sqlite3+from pathlib import Path++import pytest+from alembic import command+from sqlalchemy import inspect, textfrom storage.db import create_sqlite_engine+from storage import migrationsfrom storage.models import metadata+from tests.test_sqlite_state_migration import _Pre335Connection_VAULT_TABLES = ("vault_secrets", "vault_requests", "vault_grants", "vault_audit")@@ -20,7 +28,7 @@ def test_vault_metadata_schema_matches_grant_id_tag_model(tmp_path):assert "vault_links" not in tablessecret_cols = {row[1] for row in conn.execute(text("pragma table_info(vault_secrets)"))}- assert {"name", "tags", "kind", "protection", "ciphertext", "nonce", "wrap_meta"} <= secret_cols+ assert {"name", "tags", "kind", "protection", "ciphertext", "nonce", "wrap_meta", "fields"} <= secret_colsassert "group_name" not in secret_colssecret_indexes = {row[1] for row in conn.execute(text("select seq, name from pragma_index_list('vault_secrets')"))}assert "uq_vault_secrets_name_folded" in secret_indexes@@ -47,3 +55,125 @@ def test_vault_metadata_schema_matches_grant_id_tag_model(tmp_path):} <= grant_colsassert "scope_type" not in grant_colsassert "scope_ref" not in grant_cols+++def test_vault_fields_migration_round_trip_preserves_old_rows(tmp_path: Path, monkeypatch):+ db_path = tmp_path / "vault_migration.sqlite"+ migrations.run_migrations(db_path, revision="20261012_0064")++ with sqlite3.connect(db_path) as conn:+ conn.execute(+ """+ insert into vault_secrets (+ id, name, kind, protection, source, ciphertext, nonce, wrap_meta,+ public_meta, use_count, created_at, updated_at+ ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)+ """,+ (+ "vlt_old",+ "OLD_SECRET",+ "static",+ "standard",+ "manual",+ "ct-old",+ "n-old",+ "wm-old",+ json.dumps({"description": "legacy"}),+ 0,+ "2026-10-13T00:00:00+00:00",+ "2026-10-13T00:00:00+00:00",+ ),+ )+ cursor = conn.execute("select * from vault_secrets where id = ?", ("vlt_old",))+ original_row = cursor.fetchone()+ original_columns = ", ".join(column[0] for column in cursor.description)+ conn.commit()++ migrations.run_migrations(db_path)+ with sqlite3.connect(db_path) as conn:+ columns = {row[1] for row in conn.execute("pragma table_info(vault_secrets)")}+ row = conn.execute(+ "select name, ciphertext, public_meta, fields from vault_secrets where id = ?",+ ("vlt_old",),+ ).fetchone()+ assert "fields" in columns+ assert row == ("OLD_SECRET", "ct-old", json.dumps({"description": "legacy"}), None)++ real_connect = sqlite3.connect++ def legacy_connect(*args, **kwargs):+ kwargs["factory"] = _Pre335Connection+ return real_connect(*args, **kwargs)++ monkeypatch.setattr(sqlite3, "connect", legacy_connect)+ monkeypatch.setattr(sqlite3.dbapi2, "connect", legacy_connect)+ command.downgrade(migrations.alembic_config(db_path), "20261012_0064")+ with sqlite3.connect(db_path) as conn:+ columns = {row[1] for row in conn.execute("pragma table_info(vault_secrets)")}+ row = conn.execute(+ "select name, ciphertext, public_meta from vault_secrets where id = ?",+ ("vlt_old",),+ ).fetchone()+ assert "fields" not in columns+ assert row == ("OLD_SECRET", "ct-old", json.dumps({"description": "legacy"}))+ assert conn.execute(+ f"select {original_columns} from vault_secrets where id = ?", ("vlt_old",)+ ).fetchone() == original_row+ indexes = {row[1] for row in conn.execute("pragma index_list(vault_secrets)")}+ assert {"ix_vault_secrets_name_kind", "uq_vault_secrets_name_folded"} <= indexes+ assert [row[2] for row in conn.execute("pragma index_info(ix_vault_secrets_name_kind)")] == ["name", "kind"]+ conn.execute(+ "insert into vault_secrets (id, name, created_at, updated_at) values ('vlt_other', 'OTHER', 'now', 'now')"+ )+ for duplicate in ("OLD_SECRET", "old_secret"):+ with pytest.raises(sqlite3.IntegrityError, match="UNIQUE constraint failed"):+ conn.execute(+ "insert into vault_secrets (id, name, created_at, updated_at) values (?, ?, 'now', 'now')",+ (f"vlt_duplicate_{duplicate}", duplicate),+ )+ assert conn.execute("pragma integrity_check").fetchone() == ("ok",)+ engine = create_sqlite_engine(db_path)+ try:+ assert {"name": "uq_vault_secrets_name", "column_names": ["name"]} in inspect(engine).get_unique_constraints("vault_secrets")+ finally:+ engine.dispose()+++def test_head_repair_adds_missing_fields_column_without_dropping_rows(tmp_path: Path):+ db_path = tmp_path / "vault_repair.sqlite"+ engine = create_sqlite_engine(db_path)+ metadata.create_all(engine)+ engine.dispose()+ with sqlite3.connect(db_path) as conn:+ conn.execute('alter table "vault_secrets" drop column "fields"')+ conn.execute(+ """+ insert into vault_secrets (+ id, name, kind, protection, source, ciphertext, nonce, wrap_meta,+ use_count, created_at, updated_at+ ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)+ """,+ (+ "vlt_repair",+ "REPAIR_SECRET",+ "static",+ "standard",+ "manual",+ "ct-repair",+ "n-repair",+ "wm-repair",+ 0,+ "2026-10-13T00:00:00+00:00",+ "2026-10-13T00:00:00+00:00",+ ),+ )+ conn.commit()+ assert migrations.background_tables_ready(db_path) is False+ migrations.run_migrations(db_path)+ assert migrations.background_tables_ready(db_path) is True+ with sqlite3.connect(db_path) as conn:+ assert "fields" in {row[1] for row in conn.execute("pragma table_info(vault_secrets)")}+ assert conn.execute(+ "select name, ciphertext, fields from vault_secrets where id = ?",+ ("vlt_repair",),+ ).fetchone() == ("REPAIR_SECRET", "ct-repair", None)diff --git a/tests/test_vault_service.py b/tests/test_vault_service.pyindex e14359784..ea811a3b4 100644--- a/tests/test_vault_service.py+++ b/tests/test_vault_service.py@@ -17,6 +17,7 @@ from storage.models import (agent_sessions,metadata,state_meta,+ vault_audit,vault_auth_factors,vault_grants,vault_requests,@@ -97,6 +98,10 @@ def test_secret_metadata_is_global_name_plus_tags(vault):assert meta["tags"] == ["prod", "skill:deploy"]assert "group" not in metaassert "preview" not in meta+ assert meta["default_field"] == "value"+ assert meta["fields"] == ["value"]+ assert meta["last_used_at"] is None+ assert meta["policy"] == {}with vault.connect() as conn:row = conn.execute(select(vault_secrets).where(vault_secrets.c.name == "OPENAI_API_KEY")).mappings().one()@@ -327,6 +332,538 @@ def test_skill_links_are_stored_as_skill_tags(vault):assert meta["tags"] == ["github", "skill:github-release"]+ "value",+ ["", "value ", " value", "Value", "value-name", "value.name", "a" * 65, None],+)+def test_validate_field_name_is_strict(value):+ with pytest.raises(vs.InvalidFieldNameError):+ vs.validate_field_name(value)+++def test_provision_field_spec_contains_only_valid_distinct_labels():+ assert vs.normalize_provision_spec({"fields": ["username", "password"]}) == {+ "fields": ["username", "password"], "default_field": "username",+ }+ assert vs.normalize_provision_spec({+ "fields": ["username", "password"], "default_field": "password",+ })["default_field"] == "password"+ for invalid in [+ {"default_field": "password"},+ {"fields": []},+ {"fields": ["password", "password"]},+ {"fields": ["username"], "default_field": "password"},+ {"fields": ["password "]},+ {"fields": [{"name": "password", "value": "plaintext"}]},+ ]:+ with pytest.raises(vs.VaultServiceError):+ vs.normalize_provision_spec(invalid)+++def test_fields_use_canonical_records_and_default_label_fallback(vault):+ _create(+ vault,+ name="lowerSecret",+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )++ with vault.begin() as conn:+ meta = vs.get_secret_meta(conn, "lowerSecret")+ default_ref = vs.get_secret_record_meta(conn, "lowerSecret.password")+ extra_ref = vs.get_secret_record_meta(conn, "lowerSecret.username")++ assert meta["default_field"] == "password"+ assert meta["fields"] == ["password", "username"]+ assert vs.secret_record_names(meta) == ["lowerSecret", "lowerSecret.username"]+ assert default_ref["record_name"] == "lowerSecret"+ assert default_ref["field"] == "password"+ assert extra_ref["record_name"] == "lowerSecret.username"+ assert all(key not in json.dumps(meta) for key in ("ciphertext", "nonce", "wrap_meta"))+ assert vs.get_envelope(conn, "lowerSecret") == _sealed("lowersecret")+ assert vs.get_envelope(conn, "lowerSecret.username") == _sealed("username")++ conn.execute(+ vault_secrets.update()+ .where(vault_secrets.c.name == "lowerSecret")+ .values(public_meta=json.dumps({"default_field": "INVALID"}))+ )+ assert vs.get_secret_meta(conn, "lowerSecret")["default_field"] == "value"++[email protected]("protection", ["standard", "protected"])+def test_default_rename_is_metadata_only_and_collision_safe(vault, protection):+ _create(+ vault,+ name="LOGIN",+ protection=protection,+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ policy={"always_ask": True},+ )++ with vault.begin() as conn:+ request = vs.create_access_request(conn, "LOGIN")+ grant = _grant_from_request(conn, request)+ pending = vs.create_access_request(conn, "LOGIN")+ pending_versions = pending["card"]["grant_options"][0]["member_versions"]+ before = vs.get_secret_meta(conn, "LOGIN")+ get_envelope = vs.get_protected_envelope if protection == "protected" else vs.get_envelope+ default_envelope = get_envelope(conn, "LOGIN")+ renamed = vs.update_secret_metadata(conn, "LOGIN", default_field="credential")+ after = vs.get_secret_meta(conn, "LOGIN")++ assert renamed["default_field"] == "credential"+ assert renamed["fields"] == ["credential", "username"]+ assert renamed["policy"] == {"always_ask": True}+ assert after["updated_at"] == before["updated_at"]+ hydrated = vs.get_request(conn, pending["id"])+ assert hydrated["status"] == "pending"+ assert hydrated["card"]["grant_options"][0]["member_versions"] == pending_versions+ assert hydrated["card"]["grant_options"][0]["member_fields"] == [+ {"name": "LOGIN", "kind": "static", "default_field": "credential", "fields": ["credential", "username"]}+ ]+ # The persisted authorization snapshot is unchanged; only its UI projection is current.+ stored = conn.execute(select(vault_requests.c.delivery).where(vault_requests.c.id == pending["id"])).scalar_one()+ assert json.loads(stored)["card"]["grant_options"][0]["member_fields"][0]["default_field"] == "password"+ assert _grant_from_request(conn, pending)["status"] == "active"+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "active"+ assert get_envelope(conn, "LOGIN") == default_envelope+ with pytest.raises(vs.RecordMismatchError):+ vs.update_secret_field(+ conn, "LOGIN", "password", _sealed("stale-default"), record="LOGIN",+ expected_updated_at=before["updated_at"],+ )+ with pytest.raises(vs.FieldExistsError):+ vs.update_secret_metadata(conn, "LOGIN", default_field="username")+ assert get_envelope(conn, "LOGIN") == default_envelope++[email protected]("malformed", ["invalid_json", "non_array", "bad_entry", "duplicate", "default_collision"])[email protected]("protection", ["standard", "protected"])+def test_corrupt_fields_disable_mutations_without_losing_bytes(vault, caplog, malformed, protection):+ _create(vault, name="LOGIN", protection=protection, fields=[{"name": "username", "sealed": _sealed("username")}])+ with vault.begin() as conn:+ stored = conn.execute(select(vault_secrets.c.fields).where(vault_secrets.c.name == "LOGIN")).scalar_one()+ valid = json.loads(stored)+ damaged = {+ "invalid_json": '{"unparseable":',+ "non_array": '{"name":"username"}',+ "bad_entry": json.dumps([*valid, {"name": "password", "ciphertext": "must-not-disappear"}]),+ "duplicate": json.dumps([*valid, valid[0]]),+ "default_collision": json.dumps([*valid, {**valid[0], "name": "value"}]),+ }[malformed]+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "LOGIN").values(fields=damaged))+ caplog.clear()+ meta = vs.get_secret_meta(conn, "LOGIN")+ assert meta["fields"] == ["value"]+ assert meta["fields_state"] == "corrupt"+ assert vs.list_secrets(conn)[0]["fields_state"] == "corrupt"+ get_envelope = vs.get_protected_record_envelope if protection == "protected" else vs.get_envelope+ assert get_envelope(conn, "LOGIN") == _sealed("login")+ assert get_envelope(conn, "LOGIN.value") == _sealed("login")+ assert sum("corrupt fields" in entry.message.lower() for entry in caplog.records) == 1+ assert "must-not-disappear" not in caplog.text+ before = dict(conn.execute(select(vault_secrets).where(vault_secrets.c.name == "LOGIN")).mappings().one())+ with pytest.raises(vs.FieldsCorruptError):+ get_envelope(conn, "LOGIN.username")+ operations = [+ lambda: vs.update_secret_field(conn, "LOGIN", "totp", _sealed("new"), record="LOGIN.totp"),+ lambda: vs.update_secret_field(conn, "LOGIN", "username", _sealed("new"), record="LOGIN.username"),+ lambda: vs.update_secret_field(conn, "LOGIN", "value", _sealed("new"), record="LOGIN"),+ lambda: vs.remove_secret_field(conn, "LOGIN", "username"),+ lambda: vs.update_secret_metadata(conn, "LOGIN", default_field="password"),+ lambda: vs.rotate_secret(conn, "LOGIN", _sealed("new")),+ ]+ for operation in operations:+ with pytest.raises(vs.FieldsCorruptError):+ operation()+ after = dict(conn.execute(select(vault_secrets).where(vault_secrets.c.name == "LOGIN")).mappings().one())+ assert after == before+ assert after["fields"] == damaged+ assert not list(conn.execute(select(vault_audit.c.id).where(vault_audit.c.event == "updated")))+++def test_ordinary_metadata_preserves_approval_and_policy_edits_expire_it(vault):+ _create(+ vault, name="LOGIN", protection="protected", description="old",+ policy={"always_ask": True, "allowed_hosts": ["example.com"]},+ )+ with vault.begin() as conn:+ before = vs.get_secret_meta(conn, "LOGIN")+ request = vs.create_access_request(conn, "LOGIN")+ edited = vs.update_secret_metadata(conn, "LOGIN", description="new", tags=["new"])+ assert edited["updated_at"] == before["updated_at"]+ hydrated = vs.get_request(conn, request["id"])+ assert hydrated["card"]["grant_options"][0]["unlock_material"][0]["name"] == "LOGIN"+ grant = _grant_from_request(conn, request)+ scopes = []+ updated = vs.update_secret_metadata(+ conn, "LOGIN", policy={"allowed_hosts": ["new.example.com"]}, release_scopes=scopes,+ )+ assert updated["policy"] == {"always_ask": True, "allowed_hosts": ["new.example.com"]}+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"+ assert scopes == [{"grant_id": grant["id"]}]++[email protected]("operation", ["add", "replace_default", "replace_extra", "remove"])+def test_field_write_cas_without_explicit_version_has_no_conflict_side_effects(vault, monkeypatch, operation):+ _create(+ vault, name="LOGIN", protection="protected",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ with vault.begin() as conn:+ grant = _grant_from_request(conn, vs.create_access_request(conn, "LOGIN"))+ pending = vs.create_access_request(conn, "LOGIN")++ require_management = vs._require_secret_resource_management+ raced = False++ def write_after_snapshot(conn, row, context):+ nonlocal raced+ snapshot = require_management(conn, row, context)+ if not raced:+ raced = True+ with vault.begin() as winner:+ vs.update_secret_field(winner, "LOGIN", "other", _sealed("winner"), record="LOGIN.other")+ return snapshot++ monkeypatch.setattr(vs, "_require_secret_resource_management", write_after_snapshot)+ release_scopes = []+ with vault.begin() as conn:+ with pytest.raises(vs.SecretConflictError):+ if operation == "remove":+ vs.remove_secret_field(conn, "LOGIN", "username", release_scopes=release_scopes)+ else:+ field = {"add": "totp", "replace_default": "value", "replace_extra": "username"}[operation]+ record = "LOGIN" if field == "value" else f"LOGIN.{field}"+ vs.update_secret_field(conn, "LOGIN", field, _sealed("loser"), record=record, release_scopes=release_scopes)+ assert vs.get_secret_meta(conn, "LOGIN")["fields"] == ["value", "username", "other"]+ assert vs.get_protected_envelope(conn, "LOGIN") == _sealed("login")+ assert vs.get_protected_envelope(conn, "LOGIN.username") == _sealed("username")+ assert vs.get_protected_envelope(conn, "LOGIN.other") == _sealed("winner")+ # Only the winning write changed authorization and produced a field audit.+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"+ assert vs.get_request(conn, pending["id"])["status"] == "expired"+ assert vs.GRANT_RUNTIME_CACHE.covered_names(grant["id"]) == []+ updates = list(conn.execute(select(vault_audit.c.delivery).where(vault_audit.c.event == "updated")).scalars())+ assert [json.loads(payload)["field"] for payload in updates] == ["other"]+ assert release_scopes == []++[email protected]("field,record", [("value", "LOGIN"), ("password", "LOGIN.password")])+def test_protected_field_write_rejects_rename_after_record_resolution(vault, monkeypatch, field, record):+ _create(vault, name="LOGIN", protection="protected")+ with vault.begin() as conn:+ grant = _grant_from_request(conn, vs.create_access_request(conn, "LOGIN"))+ pending = vs.create_access_request(conn, "LOGIN")+ before = vs.get_secret_meta(conn, "LOGIN")+ original = vs._require_secret_resource_management+ raced = False++ def rename_after_snapshot(conn, row, context):+ nonlocal raced+ snapshot = original(conn, row, context)+ if not raced:+ raced = True+ with vault.begin() as winner:+ vs.update_secret_metadata(winner, "LOGIN", default_field="password")+ return snapshot++ monkeypatch.setattr(vs, "_require_secret_resource_management", rename_after_snapshot)+ release_scopes = []+ with vault.begin() as conn:+ with pytest.raises(vs.RecordMismatchError):+ vs.update_secret_field(conn, "LOGIN", field, _sealed("loser"), record=record, release_scopes=release_scopes)+ assert vs.get_protected_envelope(conn, "LOGIN") == _sealed("login")+ after = vs.get_secret_meta(conn, "LOGIN")+ assert after["updated_at"] == before["updated_at"]+ assert after["fields"] == ["password"]+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "active"+ assert vs.get_request(conn, pending["id"])["status"] == "pending"+ assert release_scopes == []++[email protected]("operation", ["rename", "pin", "rotate"])+def test_metadata_writers_do_not_overwrite_a_concurrent_description(vault, monkeypatch, operation):+ _create(vault, name="LOGIN", description="old")+ original = vs._require_secret_resource_management+ raced = False++ def edit_after_snapshot(conn, row, context):+ nonlocal raced+ snapshot = original(conn, row, context)+ if not raced:+ raced = True+ with vault.begin() as winner:+ vs.update_secret_metadata(winner, "LOGIN", description="concurrent")+ return snapshot++ monkeypatch.setattr(vs, "_require_secret_resource_management", edit_after_snapshot)+ with vault.begin() as conn:+ with pytest.raises(vs.SecretConflictError):+ if operation == "rename":+ vs.update_secret_metadata(conn, "LOGIN", default_field="password")+ elif operation == "pin":+ vs.store_pubkey_pin(conn, "LOGIN", {"public_key": "public", "fingerprint": "fingerprint"})+ else:+ vs.rotate_secret(conn, "LOGIN", _sealed("loser"))+ assert vs.get_secret_meta(conn, "LOGIN")["description"] == "concurrent"+ assert vs.get_envelope(conn, "LOGIN") == _sealed("login")+++def test_field_writes_replace_add_remove_with_versioned_cas(vault):+ _create(vault, name="LOGIN")++ with vault.begin() as conn:+ original = vs.get_secret_meta(conn, "LOGIN")+ added = vs.update_secret_field(+ conn,+ "LOGIN",+ "username",+ _sealed("username"),+ record="LOGIN.username",+ expected_updated_at=original["updated_at"],+ )+ replaced = vs.update_secret_field(+ conn,+ "LOGIN",+ "value",+ _sealed("replacement"),+ record="LOGIN",+ expected_updated_at=added["updated_at"],+ )++ assert replaced["updated_at"] > added["updated_at"]+ assert vs.get_envelope(conn, "LOGIN") == _sealed("replacement")+ with pytest.raises(vs.SecretConflictError):+ vs.update_secret_field(+ conn,+ "LOGIN",+ "username",+ _sealed("stale"),+ record="LOGIN.username",+ expected_updated_at=original["updated_at"],+ )+ assert vs.get_secret_meta(conn, "LOGIN")["fields"] == ["value", "username"]++ removed = vs.remove_secret_field(+ conn,+ "LOGIN",+ "username",+ expected_updated_at=replaced["updated_at"],+ )+ assert removed["fields"] == ["value"]+ assert removed["updated_at"] > replaced["updated_at"]+ with pytest.raises(vs.SecretConflictError):+ vs.remove_secret_field(+ conn,+ "LOGIN",+ "username",+ expected_updated_at=replaced["updated_at"],+ )+++def test_field_limits_duplicates_and_version_monotonicity(vault):+ with vault.begin() as conn:+ with pytest.raises(vs.VaultServiceError, match="fields must be an array"):+ vs.create_secret(conn, name="INVALID", sealed=_sealed(), fields={})+ with pytest.raises(vs.FieldsNotSupportedError):+ vs.create_secret(+ conn, name="INVALID", sealed=_sealed(), kind="keypair",+ fields=[{"name": "username", "sealed": _sealed()}],+ )+ for names in [["password"], ["username", "username"]]:+ with pytest.raises(vs.FieldExistsError):+ vs.create_secret(+ conn, name="INVALID", sealed=_sealed(), default_field="password",+ fields=[{"name": name, "sealed": _sealed()} for name in names],+ )+ with pytest.raises(vs.TooManyFieldsError):+ vs.create_secret(+ conn, name="INVALID", sealed=_sealed(),+ fields=[{"name": f"field{i}", "sealed": _sealed()} for i in range(32)],+ )+ vs.create_secret(+ conn, name="LOGIN", sealed=_sealed(),+ fields=[{"name": f"field{i}", "sealed": _sealed()} for i in range(31)],+ )+ with pytest.raises(vs.TooManyFieldsError):+ vs.update_secret_field(conn, "LOGIN", "overflow", _sealed(), record="LOGIN.overflow")+ with pytest.raises(vs.InvalidRequestError, match="default field"):+ vs.remove_secret_field(conn, "LOGIN", "value")+ with pytest.raises(vs.FieldNotFoundError, match="fields: value, field0"):+ vs.get_envelope(conn, "LOGIN.unknown")+ # A persisted future timestamp models a clock that moved backwards.+ future = "2100-01-01T00:00:00+00:00"+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "LOGIN").values(updated_at=future))+ replaced = vs.update_secret_field(conn, "LOGIN", "field0", _sealed("replacement"), record="LOGIN.field0")+ assert replaced["updated_at"] == "2100-01-01T00:00:00.000001+00:00"+ removed = vs.remove_secret_field(conn, "LOGIN", "field0")+ assert removed["updated_at"] == "2100-01-01T00:00:00.000002+00:00"+ assert vs.get_envelope(conn, "LOGIN.field1") == _sealed()+++def test_keypair_field_refs_and_mutations_are_rejected(vault):+ _create(vault, name="SIGNING_KEY", kind="keypair", signer_kind="local")++ with vault.begin() as conn:+ with pytest.raises(vs.FieldsNotSupportedError):+ vs.get_secret_record_meta(conn, "SIGNING_KEY.value")+ with pytest.raises(vs.FieldsNotSupportedError):+ vs.update_secret_field(conn, "SIGNING_KEY", "value", _sealed("replacement"), record="SIGNING_KEY")+ with pytest.raises(vs.FieldsNotSupportedError):+ vs.remove_secret_field(conn, "SIGNING_KEY", "value")+++def test_selector_records_preserve_secret_case_and_reject_empty_alias(vault):+ _create(+ vault,+ name="lowerSecret",+ protection="protected",+ tags=["deploy"],+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )++ with vault.begin() as conn:+ expanded = vs.expand_value_delivery_selector(conn, env=["lowerSecret.username"])+ assert expanded["secrets"] == [+ {+ "name": "lowerSecret",+ "field": "username",+ "record": "lowerSecret.username",+ "env": "lowerSecret_USERNAME",+ "kind": "static",+ "protection": "protected",+ }+ ]+ tagged = vs.expand_value_delivery_selector(conn, tags=["deploy"])+ assert [item["env"] for item in tagged["secrets"]] == [+ "lowerSecret",+ "lowerSecret_USERNAME",+ ]+ with pytest.raises(vs.InvalidRequestError):+ vs.expand_value_delivery_selector(conn, env=["=lowerSecret"])+ default_ref = vs.expand_value_delivery_selector(conn, env=["lowerSecret.value"])+ assert default_ref["secrets"][0]["record"] == "lowerSecret"+ assert default_ref["secrets"][0]["env"] == "lowerSecret_VALUE"+ for conflict in [+ ["lowerSecret", "lowerSecret.value"],+ ["SAME=lowerSecret", "SAME=lowerSecret.username"],+ ]:+ with pytest.raises(vs.InvalidRequestError):+ vs.expand_value_delivery_selector(conn, env=conflict)+++def test_access_request_deduplicates_secret_members_and_exposes_field_metadata(vault):+ _create(+ vault,+ name="PROTECTED_LOGIN",+ protection="protected",+ default_field="password",+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )++ with vault.begin() as conn:+ request = vs.create_access_request(+ conn,+ source_selector={"env": ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]},+ )+ option = request["card"]["grant_options"][0]+ assert option["member_snapshot"] == ["PROTECTED_LOGIN"]+ assert option["member_fields"] == [+ {+ "name": "PROTECTED_LOGIN",+ "kind": "static",+ "default_field": "password",+ "fields": ["password", "username"],+ }+ ]+ assert [item["name"] for item in option["unlock_material"]] == [+ "PROTECTED_LOGIN",+ "PROTECTED_LOGIN.username",+ ]+ assert request["card"]["secret_unlock_material"] == {+ "name": "PROTECTED_LOGIN",+ "kind": "static",+ "envelope": {+ "ciphertext": "ct-protected_login",+ "nonce": "n-protected_login",+ "wrap_meta": "wm-protected_login",+ },+ }+ agent_payload = vs.get_request(conn, request["id"], audience=vs.REQUEST_AUDIENCE_AGENT)+ persisted = json.loads(conn.execute(+ select(vault_requests.c.delivery).where(vault_requests.c.id == request["id"])+ ).scalar_one())+ for payload in [agent_payload, persisted]:+ encoded = json.dumps(payload)+ assert "ciphertext" not in encoded+ assert "unlock_material" not in encoded+ assert payload["card"]["grant_options"][0]["member_fields"] == option["member_fields"]+ # Legacy binding issues one approval per record. Retain the default+ # approval while the next field receives its own release context.+ for name in ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]:+ recorded = vs.record_request_agent_binding_approvals(+ conn, request["id"],+ {"grant_id": option["grant_id"], "items": [{"name": name}]},+ )+ assert [+ item["items"][0]["name"]+ for item in recorded["delivery"]["agent_binding_approvals"]+ ] == ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]+ grant = _grant_from_request(conn, request)+ resolved = vs.resolve_secret_access(conn, "PROTECTED_LOGIN.username")+ assert resolved["grant"]["member_snapshot"] == ["PROTECTED_LOGIN"]+ assert resolved["envelope"] == _sealed("username")+ scopes = []+ vs.update_secret_field(conn, "PROTECTED_LOGIN", "username", _sealed("new"), record="PROTECTED_LOGIN.username", release_scopes=scopes)+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"+ assert scopes == [{"grant_id": grant["id"]}]+ next_grant = _grant_from_request(conn, vs.create_access_request(conn, "PROTECTED_LOGIN"))+ pending = vs.create_access_request(conn, "PROTECTED_LOGIN")+ scopes.clear()+ vs.remove_secret_field(conn, "PROTECTED_LOGIN", "username", release_scopes=scopes)+ assert vs.get_request(conn, pending["id"])["status"] == "expired"+ assert vs.get_grant_created_by_request(conn, next_grant["request_id"])["status"] == "expired"+ assert scopes == [{"grant_id": next_grant["id"]}]+++def test_standard_ask_card_persists_fields_and_field_access_uses_secret_members(vault):+ _create(+ vault, name="LOGIN", policy={"always_ask": True},+ fields=[{"name": "username", "sealed": _sealed("username")}],+ )+ with vault.begin() as conn:+ request = vs.create_access_request(conn, "LOGIN.username", audience=vs.REQUEST_AUDIENCE_AGENT)+ option = request["card"]["grant_options"][0]+ assert request["secret_name"] == "LOGIN"+ assert option["member_snapshot"] == ["LOGIN"]+ assert option["member_fields"] == [+ {"name": "LOGIN", "kind": "static", "default_field": "value", "fields": ["value", "username"]}+ ]+ assert "unlock_material" not in json.dumps(request)+++def test_delivery_use_count_is_per_secret_and_audit_lists_fields(vault):+ _create(vault, name="LOGIN", fields=[{"name": "username", "sealed": _sealed("username")}])++ with vault.begin() as conn:+ identities = vs.capture_delivery_identities(conn, ["LOGIN", "LOGIN.username"])+ vs.record_deliveries(conn, identities, mode="run")+ meta = vs.get_secret_meta(conn, "LOGIN")+ events = conn.execute(+ select(vs.vault_audit.c.delivery).where(+ vs.vault_audit.c.secret_name == "LOGIN",+ vs.vault_audit.c.event == "delivered",+ )+ ).scalars().all()++ assert meta["use_count"] == 1+ assert len(events) == 1+ assert json.loads(events[0])["fields"] == ["value", "username"]++def test_selector_expansion_unions_env_tags_and_skills(vault):_create(vault, name="A_KEY", protection="protected", tags=["deploy"])_create(vault, name="B_KEY", protection="standard", tags=["deploy", "skill:release"])@@ -342,9 +879,30 @@ def test_selector_expansion_unions_env_tags_and_skills(vault):assert expanded["source_selector"] == {"env": ["LOCAL_C=C_KEY"], "tags": ["deploy", "skill:release"]}assert expanded["secrets"] == [- {"name": "C_KEY", "env": "LOCAL_C", "kind": "static", "protection": "standard"},- {"name": "A_KEY", "env": "A_KEY", "kind": "static", "protection": "protected"},- {"name": "B_KEY", "env": "B_KEY", "kind": "static", "protection": "standard"},+ {+ "name": "C_KEY",+ "field": "value",+ "record": "C_KEY",+ "env": "LOCAL_C",+ "kind": "static",+ "protection": "standard",+ },+ {+ "name": "A_KEY",+ "field": "value",+ "record": "A_KEY",+ "env": "A_KEY",+ "kind": "static",+ "protection": "protected",+ },+ {+ "name": "B_KEY",+ "field": "value",+ "record": "B_KEY",+ "env": "B_KEY",+ "kind": "static",+ "protection": "standard",+ },]@@ -367,7 +925,14 @@ def test_selector_allows_shell_env_alias_for_secret(vault):assert expanded["source_selector"] == {"env": ["api_key=PROTECTED_KEY"]}assert expanded["secrets"] == [- {"name": "PROTECTED_KEY", "env": "api_key", "kind": "static", "protection": "protected"}+ {+ "name": "PROTECTED_KEY",+ "field": "value",+ "record": "PROTECTED_KEY",+ "env": "api_key",+ "kind": "static",+ "protection": "protected",+ }]diff --git a/tests/test_web_push_provider_invalidation_migration.py b/tests/test_web_push_provider_invalidation_migration.pyindex f10c9e9ce..ad7f9f8b1 100644--- a/tests/test_web_push_provider_invalidation_migration.py+++ b/tests/test_web_push_provider_invalidation_migration.py@@ -69,7 +69,7 @@ def test_upgrade_keeps_legacy_disabled_failure_opted_out(tmp_path):web_push_service.mark_send_failure(conn, endpoint=enabled["endpoint"], disable=True)with sqlite3.connect(path) as conn:assert conn.execute("select version_num from alembic_version").fetchone() == (- "20261012_0064",+ "20261013_0065",)command.downgrade(migrations.alembic_config(path), "20260907_0061")diff --git a/ui/src/components/ui/vault-approval-card.test.tsx b/ui/src/components/ui/vault-approval-card.test.tsxindex 01f9e996e..8aab6f8c8 100644--- a/ui/src/components/ui/vault-approval-card.test.tsx+++ b/ui/src/components/ui/vault-approval-card.test.tsx@@ -121,6 +121,43 @@ const approveWhenReady = async () => {// placeholder, and a refresh during the release supersedes the contexts it is releasing. The// VaultsPage reveal tests cover only the reveal context, not these binding contexts.describe('VaultApprovalCard protected access approval', () => {+ // Per-record DEKs must survive secret-level grouping. Single-record approvals do not catch+ // deduplicating material by its base secret name or omitting standard always-ask field labels.+ it.each(['protected', 'standard'] as const)('groups %s fields by secret and releases every protected record', async (protection) => {+ const names = ['LOGIN', 'LOGIN.username', 'LOGIN.totp'];+ const unlockMaterial = protection === 'protected' ? names.map((name) => ({ name, kind: 'static', envelope })) : [];+ const request: VaultRequest = {+ ...protectedAccess, secret_name: 'LOGIN',+ card: {+ request_type: 'access', protection, secret_names: ['LOGIN'],+ protected_secret_names: protection === 'protected' ? ['LOGIN'] : [],+ grant_options: [{+ grant_id: 'grant_1', member_snapshot: ['LOGIN'], unlock_material: unlockMaterial,+ member_fields: [{ name: 'LOGIN', default_field: 'password', fields: ['password', 'username', 'totp'] }],+ }],+ },+ };+ const batch = issuedFor(300);+ api.createVaultAgentBindingsBatch.mockResolvedValue({+ ...batch, items: names.map((name) => ({ ...batch.items[0], name })),+ });+ vault.approveProtectedRelease.mockResolvedValue(names.map(() => blindBox));+ openWindow();+ render(<I18nextProvider i18n={i18n}><VaultApprovalCard request={request} onResolved={vi.fn()} onCancel={vi.fn()} /></I18nextProvider>);+ expect(screen.getByText('password · Default')).toBeTruthy();+ expect(screen.getByText('username')).toBeTruthy();+ expect(screen.getByText('totp')).toBeTruthy();+ expect(screen.queryByText('LOGIN.username')).toBeNull();+ if (protection === 'protected') {+ await approveWhenReady();+ await vi.waitFor(() => expect(api.fulfillVaultAccessRequest).toHaveBeenCalledOnce());+ expect(vault.approveProtectedRelease.mock.calls[0][0].map((item: { material: { name: string } }) => item.material.name)).toEqual(names);+ expect(api.fulfillVaultAccessRequest.mock.calls[0][1].deks.map((item: { name: string }) => item.name)).toEqual(names);+ } else {+ expect(api.createVaultAgentBindingsBatch).not.toHaveBeenCalled();+ }+ });+it.each([{ approving: 'the remembered duration', remembered: 900, pick: null, duration: 900 },{ approving: 'a duration picked on the card', remembered: 300, pick: /^15 min$/, duration: 900 },@@ -157,7 +194,21 @@ describe('VaultApprovalCard protected access approval', () => {expect(popup.close).toHaveBeenCalledOnce();});- // Contract: the approve button waits until the contexts for the duration it shows and the sandbox+ it('shows a single custom field label in an access approval', () => {+ const request: VaultRequest = {+ ...protectedAccess,+ card: {+ request_type: 'access', protection: 'standard', secret_names: ['LOGIN'], protected_secret_names: [],+ grant_options: [{+ grant_id: 'grant_1', member_snapshot: ['LOGIN'], unlock_material: [],+ member_fields: [{ name: 'LOGIN', default_field: 'password', fields: ['password'] }],+ }],+ },+ };+ render(<I18nextProvider i18n={i18n}><VaultApprovalCard request={request} onResolved={vi.fn()} onCancel={vi.fn()} /></I18nextProvider>);+ expect(screen.getByText('password · Default')).toBeTruthy();+ });+// client are ready, so a click never has to wait on either after opening the window. Without the// wait (the regression), a click right after the card opens or the duration changes, or on a page// whose sandbox client is still building, reaches the daemon or the sandbox only after the windowdiff --git a/ui/src/components/ui/vault-approval-card.tsx b/ui/src/components/ui/vault-approval-card.tsxindex c6e0bd3d0..701ac7f4f 100644--- a/ui/src/components/ui/vault-approval-card.tsx+++ b/ui/src/components/ui/vault-approval-card.tsx@@ -16,6 +16,7 @@ import { partitionTags } from '@/lib/vaultTags';import { useProtectedVault, useVaultSandboxWarm, type ProtectedUnlockMaterial } from '@/lib/useProtectedVault';import { openVaultsInBrowser, vaultPasskeyNeedsBrowser } from '@/lib/vaultBrowserHandoff';import { vaultApprovalNeedsPasskey } from '@/lib/vaultRequestPlacement';+import { vaultHasNamedFieldShape } from '@/lib/vaultFields';import { usePreparedRequest } from '@/lib/usePreparedRequest';import { openVaultAuthorizationWindow } from '@/lib/vaultSandboxClient';import { SigningAddressList } from './signing-address-list';@@ -54,6 +55,7 @@ type GrantOption = {one_shot?: boolean;member_count?: number;member_snapshot?: string[];+ member_fields?: Array<{ name: string; default_field: string; fields: string[] }>;source_selector?: VaultSourceSelector;/** Hydrated for UI audience: the protected members of this set to DEK-release. */unlock_material?: ProtectedUnlockMaterial[];@@ -162,7 +164,7 @@ export const VaultApprovalCard: React.FC<{}, [card, isSign, option]);// Protected secret names to be granted (design: "show the protected secret names covered").const protectedNames = useMemo(() => {- const materialNames = materials.map((m) => m.name);+ const materialNames = [...new Set(materials.map((m) => m.name.split('.')[0]))];return materialNames.length ? materialNames : (card?.protected_secret_names ?? []);}, [card, materials]);const isProtected = isSign ? card?.protection === 'protected' : protectedNames.length > 0 || card?.protection === 'protected';@@ -460,6 +462,27 @@ export const VaultApprovalCard: React.FC<{</Badge>) : null}</DetailRow>+ {!isSign && memberNames.map((name) => {+ const metadata = option?.member_fields?.find((member) => member.name === name);+ const labels = metadata?.fields ?? materials+ .filter((material) => material.name === name || material.name.startsWith(`${name}.`))+ .map((material) => material.field ?? material.name.split('.')[1] ?? 'value');+ const shape = metadata ?? {+ kind: isKeypair ? 'keypair' : 'static',+ default_field: labels[0] ?? 'value',+ fields: labels,+ };+ if (isKeypair || !vaultHasNamedFieldShape(shape)) return null;+ return (+ <DetailRow key={name} label={name}>+ {labels.map((field) => (+ <Badge key={field} variant="outline" className="font-mono">+ {field}{field === metadata?.default_field ? ` · ${t('vaults.fields.default')}` : ''}+ </Badge>+ ))}+ </DetailRow>+ );+ })}{isSign && hasSchemeAddress ? (<DetailRow label={t('vaults.approval.signingAs')}><SigningAddressList addresses={schemeAddresses} />diff --git a/ui/src/components/ui/vault-secret-dialog.tsx b/ui/src/components/ui/vault-secret-dialog.tsxindex 6c95d1aef..3c623cff5 100644--- a/ui/src/components/ui/vault-secret-dialog.tsx+++ b/ui/src/components/ui/vault-secret-dialog.tsx@@ -23,7 +23,7 @@ export const VaultSecretDialog: React.FC<{name?: string;/** A pending provision request; spec / default protection / id are derived from it. */request?: VaultRequest | null;- /** An existing secret to edit (value-free metadata); mutually exclusive with create/provide. */+ /** An existing secret to edit; mutually exclusive with create/provide. */editSecret?: VaultSecret | null;/** Start on the Protected tier even when a provision request defaults to Standard: a browser* handoff carries the user's choice of Protected. It can only raise the tier, never lower it. */diff --git a/ui/src/components/ui/vault-secret-fields-editor.test.tsx b/ui/src/components/ui/vault-secret-fields-editor.test.tsxnew file mode 100644index 000000000..95dfb334f--- /dev/null+++ b/ui/src/components/ui/vault-secret-fields-editor.test.tsx@@ -0,0 +1,536 @@+// @vitest-environment jsdom+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';+import { createInstance } from 'i18next';+import { I18nextProvider, initReactI18next } from 'react-i18next';+import { afterEach, beforeEach, expect, it, vi } from 'vitest';+import { ApiError, type VaultSecret } from '@/context/ApiContext';+import en from '@/i18n/en.json';+import zh from '@/i18n/zh.json';+import { VaultSecretFieldsEditor } from './vault-secret-fields-editor';++const api = vi.hoisted(() => ({+ updateVaultSecret: vi.fn(), updateVaultSecretField: vi.fn(), deleteVaultSecretField: vi.fn(),+ listVaultSecrets: vi.fn(),+ connectWorkbenchEvents: vi.fn(() => vi.fn()),+ getVaultPubkey: vi.fn(async () => ({ public_key: 'public' })),+}));+const box = vi.hoisted(() => ({ scheme: 'test', enc: 'enc', ct: 'ciphertext' }));+const sealBlindBox = vi.hoisted(() => vi.fn(async () => box));+const vault = vi.hoisted(() => ({ status: 'unlocked', refresh: vi.fn(), sealValue: vi.fn() }));+vi.mock('@/context/ApiContext', async (original) => ({+ ...await original<typeof import('@/context/ApiContext')>(),+ useApi: () => api,+}));+vi.mock('@/lib/useProtectedVault', () => ({ useProtectedVault: () => vault }));+vi.mock('./vault-protected-unlock', () => ({ VaultProtectedUnlock: () => null }));+vi.mock('@/lib/vaultCrypto', async (original) => ({+ ...await original<typeof import('@/lib/vaultCrypto')>(), sealBlindBox,+}));+const i18n = createInstance();+void i18n.use(initReactI18next).init({+ lng: 'en', resources: { en: { translation: en }, zh: { translation: zh } }, interpolation: { escapeValue: false },+});+const secret: VaultSecret = {+ name: 'LOGIN', default_field: 'password', fields: ['password', 'username'],+ kind: 'static', protection: 'standard', signer_kind: null, source: 'user', tags: [],+ policy: {}, last_used_at: null, use_count: 0, created_at: 'created', updated_at: 'version-1',+};+type EventHandlers = {+ onConnected?: () => void;+ onVaultsUpdated?: (data: { scope: string; secret_name?: string }) => void;+};+let eventHandlers: EventHandlers | null = null;+const change = (label: string, value: string) => fireEvent.change(screen.getByLabelText(label), { target: { value } });+function deferred<T>() {+ let resolve!: (value: T) => void;+ let reject!: (reason?: unknown) => void;+ const promise = new Promise<T>((nextResolve, nextReject) => {+ resolve = nextResolve;+ reject = nextReject;+ });+ return { promise, resolve, reject };+}+const renderEditor = (entry = secret) => render(+ <I18nextProvider i18n={i18n}><VaultSecretFieldsEditor secret={entry} disabled={false} onBusyChange={vi.fn()} /></I18nextProvider>,+);+beforeEach(() => {+ api.updateVaultSecret.mockReset();+ api.updateVaultSecretField.mockReset();+ api.deleteVaultSecretField.mockReset();+ api.listVaultSecrets.mockReset();+ api.connectWorkbenchEvents.mockReset();+ api.connectWorkbenchEvents.mockImplementation((handlers: EventHandlers) => {+ eventHandlers = handlers;+ return vi.fn();+ });+ api.updateVaultSecret.mockReset();+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, updated_at: 'version-2' } });+ api.deleteVaultSecretField.mockReset();+ api.listVaultSecrets.mockResolvedValue({ ok: true, secrets: [secret] });++});+afterEach(async () => { cleanup(); eventHandlers = null; vi.clearAllMocks(); await i18n.changeLanguage('en'); });++// The editor owns metadata versions between browser encryptions. Form creation and crypto+// tests cannot catch a second field write reusing the first version, or a default rename+// accidentally turning its replacement into a dotted record.+it('updates envelope versions after replacing a field and renaming the default label', async () => {+ const rendered = renderEditor();+ change('Value for password', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledWith(+ 'LOGIN', 'password', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-1' }, { handleError: false },+ ));+ await screen.findByRole('status');+ expect((screen.getByLabelText('Value for password') as HTMLInputElement).value).toBe('');+ // A parent poll can still hand back the old object after the child accepted its own+ // successful write. The editor re-reads authoritative metadata instead of adopting it.+ api.listVaultSecrets.mockResolvedValue({+ ok: true,+ secrets: [{ ...secret, updated_at: 'version-2' }],+ });+ rendered.rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={{ ...secret }} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ expect(screen.getByLabelText('Value for username')).toBeTruthy();+ change('Value for username', 'next-user');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenLastCalledWith(+ 'LOGIN', 'username', { record: 'LOGIN.username', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false },+ ));+ await waitFor(() => expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe(''));+ const beforeRename = { ...secret, updated_at: 'version-2' };+ api.listVaultSecrets.mockResolvedValue({+ ok: true,+ secrets: [{ ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' }],+ });+ rendered.rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={beforeRename} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ api.updateVaultSecret.mockResolvedValue({ ok: true, secret: { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' } });+ change('Default field name', 'credential');+ fireEvent.click(screen.getByRole('button', { name: 'Rename' }));+ await screen.findByLabelText('Value for credential');+ expect(api.updateVaultSecret).toHaveBeenCalledWith('LOGIN', { default_field: 'credential' }, { handleError: false });+ rendered.rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={{ ...beforeRename }} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential');+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-3' } });+ change('Value for credential', 'next');+ fireEvent.click(screen.getByRole('button', { name: 'Save credential' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenLastCalledWith(+ 'LOGIN', 'credential', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false },+ ));+ expect(sealBlindBox.mock.calls.map((call) => (call as unknown[])[2])).toEqual([+ { purpose: 'seal', name: 'LOGIN' }, { purpose: 'seal', name: 'LOGIN.username' }, { purpose: 'seal', name: 'LOGIN' },+ ]);+});++it('moves a typed default value when its label is renamed', async () => {+ api.updateVaultSecret.mockResolvedValue({+ ok: true,+ secret: { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-1' },+ });+ renderEditor();+ change('Value for password', 'typed-default');+ change('Default field name', 'credential');+ fireEvent.click(screen.getByRole('button', { name: 'Rename' }));+ await waitFor(() => expect(screen.getByLabelText('Value for credential')).toBeTruthy());+ expect((screen.getByLabelText('Value for credential') as HTMLInputElement).value).toBe('typed-default');+});++it('keeps a typed default label when saving another field', async () => {+ api.updateVaultSecretField.mockResolvedValue({+ ok: true,+ secret: { ...secret, updated_at: 'version-2' },+ });+ renderEditor();+ change('Default field name', 'credential');+ change('Value for username', 'typed-extra');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await screen.findByRole('status');+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential');+});++it('accepts a server refetch after a legitimate quick rename back before parent acknowledgement', async () => {+ const renamedByUser = { ...secret, default_field: 'password', fields: ['password', 'username'] };+ const renamedBackExternally = { ...secret, default_field: 'value', fields: ['value', 'username'] };+ api.updateVaultSecret.mockResolvedValueOnce({ ok: true, secret: renamedByUser });+ const rendered = renderEditor();+ change('Default field name', 'password');+ fireEvent.click(screen.getByRole('button', { name: 'Rename' }));+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('password'));++ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [renamedBackExternally] });+ rendered.rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={renamedBackExternally} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false }));+ expect((screen.getAllByLabelText('Default field name').at(-1) as HTMLInputElement).value).toBe('value');+});++it('ignores an older refetch when a newer authoritative read finishes first', async () => {+ const older = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ const newer = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ api.listVaultSecrets.mockReturnValueOnce(older.promise).mockReturnValueOnce(newer.promise);+ renderEditor();+ const newerShape = { ...secret, default_field: 'new', fields: ['new', 'username'], updated_at: 'version-3' };+ await act(async () => {+ eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });+ eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });+ });+ await act(async () => { newer.resolve({ ok: true, secrets: [newerShape] }); await newer.promise; });+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('new'));+ await act(async () => { older.reject(new Error('older read failed')); await older.promise.catch(() => undefined); });+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('new');+ expect(screen.queryByLabelText('Value for old')).toBeNull();+ expect(screen.queryByRole('alert')).toBeNull();+});++it('invalidates an older read when its own write becomes authoritative', async () => {+ const older = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ api.listVaultSecrets.mockReturnValueOnce(older.promise);+ renderEditor();+ await act(async () => {+ eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });+ });++ const ownWrite = { ...secret, updated_at: 'version-2' };+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: true, secret: ownWrite });+ change('Value for password', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));+ await screen.findByRole('status');+ await act(async () => { older.resolve({ ok: true, secrets: [secret] }); await older.promise; });++ api.updateVaultSecretField.mockResolvedValueOnce({ ok: true, secret: { ...ownWrite, updated_at: 'version-3' } });+ change('Value for username', 'next-user');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenLastCalledWith(+ 'LOGIN', 'username', { record: 'LOGIN.username', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false },+ ));+});++it('catches up after an authoritative read lands while a write is in flight', async () => {+ const read = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ const write = deferred<{ ok: boolean; secret: VaultSecret }>();+ const newerTruth = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };+ api.listVaultSecrets.mockReturnValueOnce(read.promise).mockResolvedValueOnce({ ok: true, secrets: [newerTruth] });+ api.updateVaultSecretField.mockReturnValueOnce(write.promise);+ renderEditor();+ await act(async () => { eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' }); });+ change('Value for password', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledOnce());+ await act(async () => { read.resolve({ ok: true, secrets: [newerTruth] }); await read.promise; });+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential'));+ write.resolve({ ok: true, secret: { ...secret, updated_at: 'version-2' } });+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(2));+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential');+});++it.each(['connected', 'updated'] as const)('refetches authoritative truth on vaults.%s', async (event) => {+ const refreshed = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [refreshed] });+ renderEditor();+ await act(async () => {+ if (event === 'connected') eventHandlers?.onConnected?.();+ else eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });+ });+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential'));+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });+});++it('drops removed drafts and shows a localized notice', async () => {+ api.listVaultSecrets.mockResolvedValueOnce({+ ok: true,+ secrets: [{ ...secret, fields: ['password'], updated_at: 'version-2' }],+ });+ renderEditor();+ change('Value for username', 'draft-user');+ await act(async () => { eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' }); });+ await waitFor(() => expect(screen.getByRole('status').textContent).toContain('username'));+ expect(screen.queryByLabelText('Value for username')).toBeNull();+});++it.each(['constructor', 'tostring', 'valueof'])('treats %s as a normal field key', async (field) => {+ const entry = { ...secret, fields: ['password', field] };+ api.updateVaultSecretField.mockResolvedValue({+ ok: true,+ secret: { ...entry, updated_at: 'version-2' },+ });+ renderEditor(entry);+ const value = screen.getByLabelText(`Value for ${field}`) as HTMLInputElement;+ const save = screen.getByRole('button', { name: `Save ${field}` }) as HTMLButtonElement;+ expect(value.value).toBe('');+ expect(save.disabled).toBe(true);+ fireEvent.change(value, { target: { value: 'typed-value' } });+ expect(save.disabled).toBe(false);+ fireEvent.click(save);+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledWith(+ 'LOGIN',+ field,+ { record: `LOGIN.${field}`, blind_box: box, expected_updated_at: 'version-1' },+ { handleError: false },+ ));+ expect(sealBlindBox).toHaveBeenCalledWith(+ 'typed-value',+ { public_key: 'public' },+ { purpose: 'seal', name: `LOGIN.${field}` },+ );+});++it.each(['version-1', 'version-2'])('adopts current labels at %s while preserving default and extra drafts', async (updated_at) => {+ const { rerender } = renderEditor();+ change('Value for password', 'keep-default-draft');+ change('Value for username', 'keep-this-draft');+ const renamed = {+ ...secret,+ default_field: 'credential',+ fields: ['credential', 'username'],+ updated_at,+ };+ api.listVaultSecrets.mockResolvedValue({ ok: true, secrets: [renamed] });+ rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={renamed} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential'));+ expect((screen.getByLabelText('Value for credential') as HTMLInputElement).value).toBe('keep-default-draft');+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('keep-this-draft');+});++it('warns and disables field mutations when field metadata is corrupt', () => {+ renderEditor({ ...secret, fields_state: 'corrupt' });+ expect(screen.getByRole('alert').textContent).toBe(en.errors.fields_corrupt);+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).disabled).toBe(true);+ expect((screen.getByLabelText('Value for password') as HTMLInputElement).disabled).toBe(true);+ expect((screen.getByRole('button', { name: 'Rename' }) as HTMLButtonElement).disabled).toBe(true);+ expect((screen.getByRole('button', { name: 'Save password' }) as HTMLButtonElement).disabled).toBe(true);+ expect((screen.getByRole('button', { name: 'Remove username' }) as HTMLButtonElement).disabled).toBe(true);+ expect((screen.getByRole('button', { name: 'Add field' }) as HTMLButtonElement).disabled).toBe(true);+});++it('adopts a same-version corruption state from refreshed metadata', async () => {+ api.listVaultSecrets.mockResolvedValueOnce({+ ok: true,+ secrets: [{ ...secret, fields_state: 'corrupt' }],+ });+ const { rerender } = renderEditor();+ rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={{ ...secret, fields_state: 'corrupt' }} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ await waitFor(() => expect(screen.getByRole('alert').textContent).toBe(en.errors.fields_corrupt));+ expect((screen.getByRole('button', { name: 'Save password' }) as HTMLButtonElement).disabled).toBe(true);+});++it('requires a unique populated extra field, saves it under its record name, and confirms removal', async () => {+ renderEditor();+ fireEvent.click(screen.getByRole('button', { name: 'Add field' }));+ change('New field name', 'username');+ change('New field value', 'seed');+ expect((screen.getByRole('button', { name: 'Save field' }) as HTMLButtonElement).disabled).toBe(true);+ change('New field name', 'totp');+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, fields: ['password', 'username', 'totp'], updated_at: 'version-2' } });+ fireEvent.click(screen.getByRole('button', { name: 'Save field' }));+ await screen.findByLabelText('Value for totp');+ expect(sealBlindBox).toHaveBeenCalledWith('seed', { public_key: 'public' }, { purpose: 'seal', name: 'LOGIN.totp' });+ expect(screen.queryByRole('button', { name: 'Remove password' })).toBeNull();+ fireEvent.click(screen.getByRole('button', { name: 'Remove totp' }));+ expect(api.deleteVaultSecretField).not.toHaveBeenCalled();+ api.deleteVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, updated_at: 'version-3' } });+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));+ await waitFor(() => expect(api.deleteVaultSecretField).toHaveBeenCalledWith('LOGIN', 'totp', { expected_updated_at: 'version-2' }));+ await waitFor(() => expect(screen.queryByLabelText('Value for totp')).toBeNull());+});++it('refreshes a stale delete version without removing the newer field or retrying', async () => {+ api.deleteVaultSecretField.mockRejectedValueOnce(new ApiError('stale delete', 409, 'secret_conflict'));+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [{ ...secret, updated_at: 'version-8' }] });+ renderEditor();+ fireEvent.click(screen.getByRole('button', { name: 'Remove username' }));+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));+ expect((await screen.findByRole('alert')).textContent).toBe(en.vaults.fields.secretConflict);+ expect(api.deleteVaultSecretField).toHaveBeenCalledOnce();+ expect(screen.getByLabelText('Value for username')).toBeTruthy();+ api.deleteVaultSecretField.mockResolvedValueOnce({ ok: true, secret: { ...secret, fields: ['password'], updated_at: 'version-9' } });+ fireEvent.click(screen.getByRole('button', { name: 'Remove username' }));+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));+ await waitFor(() => expect(screen.queryByLabelText('Value for username')).toBeNull());+ expect(api.deleteVaultSecretField.mock.calls).toEqual([+ ['LOGIN', 'username', { expected_updated_at: 'version-1' }],+ ['LOGIN', 'username', { expected_updated_at: 'version-8' }],+ ]);+});++it('renders a Chinese field validation error from the stable code', async () => {+ await i18n.changeLanguage('zh');+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'field_not_found', message: 'field not found on LOGIN' });+ renderEditor();+ change(i18n.t('vaults.fields.value', { field: 'username' }), 'replacement');+ fireEvent.click(screen.getByRole('button', { name: i18n.t('vaults.fields.saveNamed', { field: 'username' }) }));+ expect((await screen.findByRole('alert')).textContent).toBe(zh.errors.field_not_found);+});++it.each(['response', 'exception'])('refreshes a conflicting version without retrying, then permits a new save (%s)', async (failure) => {+ const fresh = { ...secret, updated_at: 'version-9' };+ if (failure === 'exception') {+ api.updateVaultSecretField.mockRejectedValueOnce(new ApiError('stale version', 409, 'secret_conflict'));+ } else {+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'secret_conflict' });+ }+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [fresh] });+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...fresh, updated_at: 'version-10' } });+ renderEditor();+ change('Value for username', 'new-user');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ expect((await screen.findByRole('alert')).textContent).toBe(en.vaults.fields.secretConflict);+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });+ expect(api.updateVaultSecretField).toHaveBeenCalledOnce();+ expect(screen.queryByRole('status')).toBeNull();+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('new-user');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await screen.findByRole('status');+ expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2);+ expect(api.updateVaultSecretField.mock.calls[1][2].expected_updated_at).toBe('version-9');+});++it('seals a protected replacement with its field record and drops its entered value', async () => {+ const envelope = { ciphertext: 'ciphertext', nonce: 'nonce', wrap_meta: '{}' };+ vault.sealValue.mockImplementation(async (_name, _kind, value) => { value.clear(); return { envelope }; });+ renderEditor({ ...secret, protection: 'protected' });+ change('Value for username', '私密用户');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledWith(+ 'LOGIN', 'username', { record: 'LOGIN.username', sealed: envelope, expected_updated_at: 'version-1' }, { handleError: false },+ ));+ expect(vault.sealValue.mock.calls[0].slice(0, 2)).toEqual(['LOGIN.username', 'static']);+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('');+ expect(sealBlindBox).not.toHaveBeenCalled();+});++it('re-reads metadata and re-seals exactly once after a record mismatch', async () => {+ const renamed = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };+ api.updateVaultSecretField+ .mockResolvedValueOnce({ ok: false, code: 'record_mismatch', message: 'stale record' })+ .mockResolvedValueOnce({ ok: true, secret: { ...renamed, updated_at: 'version-3' } });+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [renamed] });+ renderEditor();+ change('Value for password', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2));+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });+ expect(api.updateVaultSecretField.mock.calls).toEqual([+ ['LOGIN', 'password', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-1' }, { handleError: false }],+ ['LOGIN', 'credential', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false }],+ ]);+ expect(sealBlindBox).toHaveBeenCalledTimes(2);+ expect((screen.getByLabelText('Value for credential') as HTMLInputElement).value).toBe('');+ expect(screen.queryByRole('alert')).toBeNull();+});++it('surfaces an extra-field record conflict without retrying under a changed default label', async () => {+ const changed = { ...secret, default_field: 'username', fields: ['username'], updated_at: 'version-2' };+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'record_mismatch', message: 'stale record' });+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [changed] });+ renderEditor();+ change('Value for username', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await waitFor(() => expect(screen.getByRole('alert')).toBeTruthy());+ expect(api.updateVaultSecretField).toHaveBeenCalledOnce();+ expect(sealBlindBox).toHaveBeenCalledOnce();+});++it('retries a record mismatch with the superseded read entry', async () => {+ const retryRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ const propRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ const renamed = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };+ api.updateVaultSecretField+ .mockResolvedValueOnce({ ok: false, code: 'record_mismatch', message: 'stale record' })+ .mockResolvedValueOnce({ ok: true, secret: { ...renamed, updated_at: 'version-3' } });+ api.listVaultSecrets.mockReturnValueOnce(retryRead.promise).mockReturnValueOnce(propRead.promise);+ const rendered = renderEditor();+ change('Value for password', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(1));+ rendered.rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={{ ...secret, updated_at: 'version-2' }} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(2));+ await act(async () => {+ propRead.resolve({ ok: true, secrets: [renamed] });+ retryRead.resolve({ ok: true, secrets: [renamed] });+ await Promise.all([propRead.promise, retryRead.promise]);+ });+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2));+ expect(api.updateVaultSecretField.mock.calls[1][2].expected_updated_at).toBe('version-2');+});++it('keeps a secret conflict after its refresh is superseded', async () => {+ const conflictRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ const propRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'secret_conflict' });+ api.listVaultSecrets.mockReturnValueOnce(conflictRead.promise).mockReturnValueOnce(propRead.promise);+ const rendered = renderEditor();+ change('Value for username', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(1));+ rendered.rerender(+ <I18nextProvider i18n={i18n}>+ <VaultSecretFieldsEditor secret={{ ...secret, updated_at: 'version-2' }} disabled={false} onBusyChange={vi.fn()} />+ </I18nextProvider>,+ );+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(2));+ await act(async () => {+ propRead.resolve({ ok: true, secrets: [secret] });+ conflictRead.resolve({ ok: true, secrets: [secret] });+ await Promise.all([propRead.promise, conflictRead.promise]);+ });+ expect((await screen.findByRole('alert')).textContent).toBe(en.vaults.fields.secretConflict);+});++it('shows a missing-secret error when a conflict refresh finds no secret', async () => {+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'secret_conflict' });+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [] });+ renderEditor();+ change('Value for username', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ expect((await screen.findByRole('alert')).textContent).toBe(en.errors.secret_not_found);+});++it('does not report a dropped draft when its field is cleared before own removal', async () => {+ api.deleteVaultSecretField.mockResolvedValueOnce({ ok: true, secret: { ...secret, fields: ['password'], updated_at: 'version-2' } });+ renderEditor();+ change('Value for username', 'temporary');+ change('Value for username', '');+ fireEvent.click(screen.getByRole('button', { name: 'Remove username' }));+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));+ await waitFor(() => expect(screen.queryByLabelText('Value for username')).toBeNull());+ expect(screen.queryByText(en.vaults.fields.draftsDropped.replace('{{fields}}', 'username'))).toBeNull();+});++it('retries once when the API client throws ApiError for record_mismatch', async () => {+ api.updateVaultSecretField+ .mockRejectedValueOnce(new ApiError('stale record', 409, 'record_mismatch'))+ .mockResolvedValueOnce({ ok: true, secret: { ...secret, updated_at: 'version-2' } });+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [secret] });+ renderEditor();+ change('Value for username', 'replacement');+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2));+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });+ expect(api.updateVaultSecretField.mock.calls[1][2]).toMatchObject({ record: 'LOGIN.username', expected_updated_at: 'version-1' });+});diff --git a/ui/src/components/ui/vault-secret-fields-editor.tsx b/ui/src/components/ui/vault-secret-fields-editor.tsxnew file mode 100644index 000000000..39c3e772c--- /dev/null+++ b/ui/src/components/ui/vault-secret-fields-editor.tsx@@ -0,0 +1,388 @@+import { useCallback, useEffect, useRef, useState } from 'react';+import { Loader2, Plus, X } from 'lucide-react';+import { useTranslation } from 'react-i18next';+import { useApi, type VaultFieldValuePayload, type VaultSecret } from '@/context/ApiContext';+import { sealBlindBox, standardCreateBlindBoxContext } from '@/lib/vaultCrypto';+import { vaultErrorMessage } from '@/lib/vaultErrors';+import { useProtectedVault } from '@/lib/useProtectedVault';+import { openVaultsInBrowser } from '@/lib/vaultBrowserHandoff';+import { MAX_VAULT_FIELDS, VAULT_FIELD_PATTERN, vaultDefaultField, vaultFieldNames, vaultRecordName } from '@/lib/vaultFields';+import { Badge } from './badge';+import { Button } from './button';+import { ConfirmDialog } from './confirm-dialog';+import { Input } from './input';+import { VaultProtectedUnlock } from './vault-protected-unlock';++type DraftReconciliation = {+ drafts: Map<string, string>;+ removed: string[];+};++function reconcileDrafts(previous: VaultSecret, next: VaultSecret, drafts: ReadonlyMap<string, string>): DraftReconciliation {+ const reconciled = new Map(drafts);+ const previousDefault = vaultDefaultField(previous);+ const nextDefault = vaultDefaultField(next);+ if (previousDefault !== nextDefault && reconciled.has(previousDefault)) {+ reconciled.set(nextDefault, reconciled.get(previousDefault) ?? '');+ reconciled.delete(previousDefault);+ }++ const names = new Set(vaultFieldNames(next));+ const removed: string[] = [];+ for (const name of reconciled.keys()) {+ if (!names.has(name)) {+ const value = reconciled.get(name);+ reconciled.delete(name);+ if (value) removed.push(name);+ }+ }+ return { drafts: reconciled, removed };+}++/** Each field mutation returns the next metadata version for the following browser envelope. */+export function VaultSecretFieldsEditor({+ secret, disabled, onBusyChange,+}: {+ secret: VaultSecret;+ disabled: boolean;+ onBusyChange: (busy: boolean) => void;+}) {+ const { t } = useTranslation();+ const api = useApi();+ const vault = useProtectedVault();+ const { refresh } = vault;+ const [current, setCurrent] = useState(secret);+ const currentRef = useRef(secret);+ const truthRevisionRef = useRef(0);+ const initialSecretRef = useRef(secret);+ const [drafts, setDraftsState] = useState<Map<string, string>>(() => new Map());+ const draftsRef = useRef<Map<string, string>>(new Map());+ const [defaultLabel, setDefaultLabel] = useState(vaultDefaultField(secret));+ const defaultLabelDirtyRef = useRef(false);+ const [newField, setNewField] = useState<string | null>(null);+ const [newValue, setNewValue] = useState('');+ const [busy, setBusy] = useState(false);+ const [error, setError] = useState<string | null>(null);+ const [saved, setSaved] = useState(false);+ const [removeField, setRemoveField] = useState<string | null>(null);+ const [draftNotice, setDraftNotice] = useState<string | null>(null);+ const fields = vaultFieldNames(current);+ const defaultField = vaultDefaultField(current);+ const isProtected = current.protection === 'protected';+ const locked = disabled || busy;+ const fieldsCorrupt = current.fields_state === 'corrupt';+ const fieldMutationLocked = locked || fieldsCorrupt;+ const canWriteValue = !isProtected || vault.status === 'unlocked';++ useEffect(() => {+ if (isProtected) void refresh();+ }, [isProtected, refresh]);++ const hasErrorCode = (result: unknown, code: string): boolean =>+ typeof result === 'object' && result !== null && 'code' in result && result.code === code;+ const conflict = () => new Error(t('vaults.fields.recordConflict'));+ const updateDrafts = useCallback((next: Map<string, string>) => {+ draftsRef.current = next;+ setDraftsState(next);+ }, []);+ const applyTruth = useCallback((next: VaultSecret, ownRename = false) => {+ const previous = currentRef.current;+ currentRef.current = next;+ truthRevisionRef.current += 1;+ setCurrent(next);+ const nextDefault = vaultDefaultField(next);+ if (ownRename || !defaultLabelDirtyRef.current) {+ setDefaultLabel(nextDefault);+ }+ if (ownRename) defaultLabelDirtyRef.current = false;+ const reconciled = reconcileDrafts(previous, next, draftsRef.current);+ updateDrafts(reconciled.drafts);+ if (reconciled.removed.length > 0) {+ setDraftNotice(t('vaults.fields.draftsDropped', { fields: reconciled.removed.join(', ') }));+ } else {+ setDraftNotice(null);+ }+ }, [t, updateDrafts]);++ const refetchSequenceRef = useRef(0);+ const invalidatePendingRefetches = useCallback(() => {+ refetchSequenceRef.current += 1;+ }, []);+ type RefetchResult = {+ status: 'applied' | 'superseded' | 'missing';+ entry: VaultSecret | null;+ };+ const refetch = useCallback(async (): Promise<RefetchResult> => {+ const sequence = ++refetchSequenceRef.current;+ try {+ const result = await api.listVaultSecrets({ cache: false });+ const next = result.secrets.find((entry) => entry.name === currentRef.current.name) ?? null;+ if (sequence !== refetchSequenceRef.current) return { status: 'superseded', entry: next };+ if (!next) return { status: 'missing', entry: null };+ applyTruth(next);+ return { status: 'applied', entry: next };+ } catch (refetchError) {+ if (sequence !== refetchSequenceRef.current) return { status: 'superseded', entry: null };+ throw refetchError;+ }+ }, [api, applyTruth]);++ const handleRefetchResult = useCallback((result: RefetchResult) => {+ if (result.status === 'missing') setError(t('errors.secret_not_found'));+ }, [t]);++ const surfaceRefetchError = useCallback((refetchError: unknown) => {+ setError(vaultErrorMessage(t, refetchError, t('vaults.dialog.errors.updateFailed')));+ }, [t]);++ useEffect(() => {+ const refreshFromEvent = () => {+ void refetch().then(handleRefetchResult).catch(surfaceRefetchError);+ };+ const disconnect = api.connectWorkbenchEvents({+ onConnected: refreshFromEvent,+ onVaultsUpdated: (data) => {+ if (!data.secret_name || data.secret_name === currentRef.current.name) refreshFromEvent();+ },+ });+ return () => disconnect?.();+ }, [api, refetch, handleRefetchResult, surfaceRefetchError]);++ useEffect(() => {+ if (secret === initialSecretRef.current) return;+ initialSecretRef.current = secret;+ // Parent updates are only a signal to read server truth; the mounted editor+ // never adopts the prop directly.+ if (secret.name !== currentRef.current.name) return;+ void refetch().then(handleRefetchResult).catch(surfaceRefetchError);+ }, [secret, refetch, handleRefetchResult, surfaceRefetchError]);++ useEffect(() => () => {+ refetchSequenceRef.current += 1;+ }, []);++ const mutate = async (+ operation: () => Promise<{ ok: boolean; secret?: VaultSecret; message?: string; code?: string }>,+ renamed = false,+ operationRefetched: () => boolean = () => false,+ ) => {+ if (locked) return;+ const writeStartTruthRevision = truthRevisionRef.current;+ const writeStartSequence = refetchSequenceRef.current;+ setBusy(true);+ onBusyChange(true);+ setError(null);+ setSaved(false);+ setDraftNotice(null);+ try {+ const result = await operation();+ if (!result.ok || !result.secret) {+ throw Object.assign(new Error(vaultErrorMessage(t, result, t('vaults.dialog.errors.updateFailed'))), { code: result.code });+ }+ const next = result.secret;+ const needsCatchup = (+ refetchSequenceRef.current !== writeStartSequence+ || truthRevisionRef.current !== writeStartTruthRevision+ ) && !operationRefetched();+ invalidatePendingRefetches();+ applyTruth(next, renamed);+ setSaved(true);+ if (needsCatchup) {+ try {+ const refreshed = await refetch();+ if (refreshed.status === 'missing') {+ setError(t('errors.secret_not_found'));+ }+ } catch (catchupError) {+ surfaceRefetchError(catchupError);+ }+ }+ } catch (err) {+ if (hasErrorCode(err, 'secret_conflict')) {+ try {+ const refreshed = await refetch();+ if (refreshed.status === 'missing') {+ setError(t('errors.secret_not_found'));+ } else {+ setError(t('vaults.fields.secretConflict'));+ }+ } catch (refreshError) {+ setError(vaultErrorMessage(t, refreshError, t('vaults.dialog.errors.updateFailed')));+ }+ } else {+ setError(vaultErrorMessage(t, err, t('vaults.dialog.errors.updateFailed')));+ }+ } finally {+ setBusy(false);+ onBusyChange(false);+ }+ };++ const saveValue = (field: string, value: string, adding = false) => {+ // Keep this one local copy only until the write settles. Protected sealing clears the+ // persistent input immediately through `clear`, while this copy permits exactly one+ // re-seal if the server reports that its record mapping changed.+ let capturedValue = value;+ const clear = (targetField = field) => {+ if (adding) {+ setNewValue('');+ return;+ }+ const next = new Map(draftsRef.current);+ next.set(targetField, '');+ updateDrafts(next);+ };+ const sealAndWrite = async (secret: VaultSecret, targetField: string, wasDefault: boolean) => {+ const latestDefault = vaultDefaultField(secret);+ if (!wasDefault && latestDefault === targetField) throw conflict();+ const exists = vaultFieldNames(secret).includes(targetField);+ if (adding ? exists : !exists) throw conflict();+ const record = vaultRecordName(secret.name, targetField, latestDefault);+ let cryptoFields: Omit<VaultFieldValuePayload, 'record' | 'expected_updated_at'>;+ if (isProtected) {+ const valueRef = { current: capturedValue };+ const sealed = await vault.sealValue(record, 'static', { valueRef, clear });+ cryptoFields = { sealed: sealed.envelope };+ } else {+ cryptoFields = {+ blind_box: await sealBlindBox(capturedValue, await api.getVaultPubkey(), standardCreateBlindBoxContext(record)),+ };+ }+ try {+ return await api.updateVaultSecretField(secret.name, targetField, {+ record,+ ...cryptoFields,+ expected_updated_at: secret.updated_at,+ }, { handleError: false });+ } catch (error) {+ if (hasErrorCode(error, 'record_mismatch')) return { ok: false, code: 'record_mismatch' };+ if (hasErrorCode(error, 'secret_conflict')) return { ok: false, code: 'secret_conflict' };+ throw error;+ }+ };+ let refetchedForRetry = false;+ void mutate(async () => {+ try {+ const wasDefault = field === defaultField;+ let savedField = field;+ let result = await sealAndWrite(current, field, wasDefault);+ if (hasErrorCode(result, 'record_mismatch')) {+ refetchedForRetry = true;+ const refreshed = await refetch();+ if (!refreshed.entry) {+ setError(t('errors.secret_not_found'));+ return { ok: false, code: 'secret_not_found' };+ }+ savedField = wasDefault ? vaultDefaultField(refreshed.entry) : field;+ result = await sealAndWrite(refreshed.entry, savedField, wasDefault);+ if (hasErrorCode(result, 'record_mismatch')) throw conflict();+ }+ if (result.ok && result.secret) {+ clear(savedField);+ if (adding) setNewField(null);+ }+ return result;+ } finally {+ capturedValue = '';+ }+ }, false, () => refetchedForRetry);+ };++ return (+ <div className="flex flex-col gap-3" onKeyDown={(event) => {+ // These inputs save through their field buttons, not the enclosing metadata form.+ if (event.key === 'Enter' && event.target instanceof HTMLInputElement) event.preventDefault();+ }}>+ <span className="text-[13px] font-medium">{t('vaults.fields.title')}</span>+ <p className="text-[11px] text-muted-foreground">{t('vaults.fields.editHelp')}</p>+ {draftNotice && (+ <p role="status" className="text-xs text-muted-foreground">{draftNotice}</p>+ )}+ {fieldsCorrupt && (+ <p role="alert" className="text-xs text-destructive-ink">{t('errors.fields_corrupt')}</p>+ )}+ {fields.map((field) => (+ <div key={field} className="flex flex-col gap-2 rounded-lg border border-border p-3">+ <div className="flex items-center gap-2">+ {field === defaultField ? (+ <>+ <Input value={defaultLabel} disabled={fieldMutationLocked}+ aria-label={t('vaults.fields.defaultName')}+ onChange={(event) => {+ defaultLabelDirtyRef.current = true;+ setDefaultLabel(event.target.value);+ }}+ className="min-w-0 font-mono" />+ <Badge variant="secondary">{t('vaults.fields.default')}</Badge>+ <Button type="button" size="sm" variant="ghost"+ disabled={fieldMutationLocked || defaultLabel === defaultField || !VAULT_FIELD_PATTERN.test(defaultLabel) || fields.includes(defaultLabel)}+ onClick={() => void mutate(+ () => api.updateVaultSecret(current.name, { default_field: defaultLabel }, { handleError: false }),+ true,+ )}>+ {t('vaults.fields.rename')}+ </Button>+ </>+ ) : (+ <>+ <span className="min-w-0 flex-1 break-all font-mono text-xs">{field}</span>+ <Button type="button" size="icon" variant="ghost" disabled={fieldMutationLocked}+ aria-label={t('vaults.fields.remove', { field })} onClick={() => setRemoveField(field)}>+ <X className="size-4" />+ </Button>+ </>+ )}+ </div>+ <div className="flex items-center gap-2">+ <Input type="password" value={drafts.get(field) ?? ''} autoComplete="off" disabled={fieldMutationLocked}+ aria-label={t('vaults.fields.value', { field })}+ placeholder={t('vaults.fields.replacePlaceholder')}+ onChange={(event) => {+ const next = new Map(draftsRef.current);+ next.set(field, event.target.value);+ updateDrafts(next);+ }} />+ <Button type="button" variant="secondary" size="sm"+ aria-label={t('vaults.fields.saveNamed', { field })}+ disabled={fieldMutationLocked || !canWriteValue || !drafts.get(field)}+ onClick={() => saveValue(field, drafts.get(field) ?? '')}>{t('vaults.fields.save')}</Button>+ </div>+ </div>+ ))}+ {newField !== null ? (+ <div className="flex flex-col gap-2 rounded-lg border border-border p-3">+ <Input value={newField} disabled={fieldMutationLocked} aria-label={t('vaults.fields.newName')}+ placeholder={t('vaults.fields.namePlaceholder')} onChange={(event) => setNewField(event.target.value)} />+ <Input type="password" value={newValue} autoComplete="off" disabled={fieldMutationLocked}+ aria-label={t('vaults.fields.newValue')} placeholder={t('vaults.dialog.valuePlaceholder')}+ onChange={(event) => setNewValue(event.target.value)} />+ <div className="flex justify-end gap-2">+ <Button type="button" variant="ghost" size="sm" disabled={locked}+ onClick={() => { setNewField(null); setNewValue(''); }}>{t('vaults.dialog.cancel')}</Button>+ <Button type="button" size="sm"+ disabled={fieldMutationLocked || !canWriteValue || !newValue || !VAULT_FIELD_PATTERN.test(newField) || fields.includes(newField)}+ onClick={() => saveValue(newField, newValue, true)}>{t('vaults.fields.save')}</Button>+ </div>+ <span className="text-[11px] text-muted-foreground">{t('vaults.fields.namesHelp')}</span>+ </div>+ ) : (+ <Button type="button" variant="ghost" size="sm" className="self-start" disabled={fieldMutationLocked || fields.length >= MAX_VAULT_FIELDS}+ onClick={() => setNewField('')}><Plus className="size-3.5" />{t('vaults.fields.add')}</Button>+ )}+ {isProtected && <VaultProtectedUnlock vault={vault} secretName={current.name}+ onContinueInBrowser={() => openVaultsInBrowser({ kind: 'edit', secretName: current.name })} />}+ {busy && <Loader2 className="size-4 animate-spin text-muted" />}+ {saved && <p role="status" className="text-xs text-mint-ink">{t('vaults.fields.saved')}</p>}+ {error && <p role="alert" className="text-xs text-destructive-ink">{error}</p>}+ <ConfirmDialog open={removeField !== null} onOpenChange={(open) => { if (!open) setRemoveField(null); }}+ title={t('vaults.fields.remove', { field: removeField })}+ description={t('vaults.fields.removeConfirm')}+ confirmLabel={t('vaults.delete')} cancelLabel={t('vaults.dialog.cancel')} destructive+ onConfirm={async () => {+ if (!removeField || fieldsCorrupt) return;+ await mutate(() => api.deleteVaultSecretField(current.name, removeField, { expected_updated_at: current.updated_at }));+ setRemoveField(null);+ }} />+ </div>+ );+}diff --git a/ui/src/components/ui/vault-secret-form.test.tsx b/ui/src/components/ui/vault-secret-form.test.tsxindex 188e7ee5e..e20494d35 100644--- a/ui/src/components/ui/vault-secret-form.test.tsx+++ b/ui/src/components/ui/vault-secret-form.test.tsx@@ -1,22 +1,175 @@/* @vitest-environment jsdom */-import { cleanup, render, waitFor } from '@testing-library/react';-import { afterEach, expect, it, vi } from 'vitest';+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';+import { afterEach, beforeEach, expect, it, vi } from 'vitest';+import { createInstance } from 'i18next';+import { I18nextProvider, initReactI18next } from 'react-i18next';+import type { ReactElement } from 'react';+import en from '@/i18n/en.json';+import type { VaultSecret } from '@/context/ApiContext';import { VaultSecretForm } from './vault-secret-form';const api = vi.hoisted(() => ({- listDependencies: vi.fn(async () => ({ ok: true, deps: [] })),+ listDependencies: vi.fn(),listVaultSecrets: vi.fn(async () => ({ secrets: [] })),listSkills: vi.fn(async () => ({ skills: [] })),createVaultSecret: vi.fn(),+ getVaultPubkey: vi.fn(async () => ({ public_key: 'public', fingerprint: 'fingerprint' })),+ connectWorkbenchEvents: vi.fn(() => vi.fn()),}));-vi.mock('@/context/ApiContext', () => ({ useApi: () => api }));-vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));-afterEach(cleanup);+const envelope = vi.hoisted(() => ({ ciphertext: 'ciphertext', nonce: 'nonce', wrap_meta: '{}' }));+const blindBox = vi.hoisted(() => ({ scheme: 'test', enc: 'enc', ct: 'ciphertext' }));+const sealBlindBox = vi.hoisted(() => vi.fn(async () => blindBox));+const vault = vi.hoisted(() => ({+ status: 'unlocked', refresh: vi.fn(), afterCreated: vi.fn(),+ sealValue: vi.fn(),+}));+vi.mock('@/context/ApiContext', async (original) => ({+ ...await original<typeof import('@/context/ApiContext')>(), useApi: () => api,+}));+vi.mock('@/lib/useProtectedVault', () => ({ useProtectedVault: () => vault }));+vi.mock('./vault-protected-unlock', () => ({ VaultProtectedUnlock: () => null }));+vi.mock('@/lib/vaultCrypto', async (original) => ({+ ...await original<typeof import('@/lib/vaultCrypto')>(), sealBlindBox,+}));+const i18n = createInstance();+void i18n.use(initReactI18next).init({+ lng: 'en', fallbackLng: 'en', resources: { en: { translation: en } }, interpolation: { escapeValue: false },+});+const form = (element: ReactElement) => <I18nextProvider i18n={i18n}>{element}</I18nextProvider>;+const change = (label: string, value: string) => fireEvent.change(screen.getByLabelText(label), { target: { value } });+beforeEach(() => {+ api.listDependencies.mockResolvedValue({ ok: true, deps: [{ id: 'avault', status: 'ready', version: '0.1.6' }] });+ api.createVaultSecret.mockResolvedValue({ ok: true });+ vault.sealValue.mockImplementation(async (_name, _kind, value) => {+ value.clear();+ return { envelope, establishingVmk: true, authzFactorRegistration: { challenge_id: 'setup' } };+ });+});+afterEach(() => { cleanup(); vi.clearAllMocks(); });it('checks only avault when the secret form opens, without creating a secret', async () => {- render(<VaultSecretForm onCancel={vi.fn()} onCreated={vi.fn()} />);+ render(form(<VaultSecretForm onCancel={vi.fn()} onCreated={vi.fn()} />));await waitFor(() => expect(api.listDependencies).toHaveBeenCalledWith({ ids: ['avault'] }));expect(api.listDependencies).toHaveBeenCalledTimes(1);expect(api.createVaultSecret).not.toHaveBeenCalled();});++// The form owns row/default selection and wire payload assembly. Existing crypto tests do not+// catch dropping a row, allowing a blank value, or sealing the default under NAME.password.+it.each(['standard', 'protected'] as const)('creates a complete %s login with canonical record names and no plaintext payload', async (protection) => {+ const onCreated = vi.fn();+ render(form(<VaultSecretForm fixedName="GITHUB_LOGIN" defaultProtection={protection} onCancel={vi.fn()} onCreated={onCreated} />));+ fireEvent.click(screen.getByRole('button', { name: 'Login template' }));+ expect(screen.queryByRole('radio', { name: 'File' })).toBeNull();+ const submit = screen.getByRole('button', { name: 'Save & let the agent continue' }) as HTMLButtonElement;+ change('Value for username', '张三');+ change('Value for password', '密碼');+ expect(submit.disabled).toBe(true);+ change('Value for totp', 'seed');+ await waitFor(() => expect(submit.disabled).toBe(false));+ fireEvent.click(submit);+ await waitFor(() => expect(onCreated).toHaveBeenCalledWith('GITHUB_LOGIN', 'created'));+ const payload = api.createVaultSecret.mock.calls[0][0];+ expect(payload.default_field).toBe('password');+ expect(payload.fields.map((field: { name: string }) => field.name)).toEqual(['username', 'totp']);+ expect(JSON.stringify(payload)).not.toMatch(/张三|密碼|seed/);+ if (protection === 'standard') {+ expect(sealBlindBox.mock.calls.map((call) => (call as unknown[])[2])).toEqual([+ { purpose: 'seal', name: 'GITHUB_LOGIN.username' },+ { purpose: 'seal', name: 'GITHUB_LOGIN' },+ { purpose: 'seal', name: 'GITHUB_LOGIN.totp' },+ ]);+ expect(payload.blind_box).toEqual(blindBox);+ expect(payload.fields).toEqual([+ { name: 'username', record: 'GITHUB_LOGIN.username', blind_box: blindBox },+ { name: 'totp', record: 'GITHUB_LOGIN.totp', blind_box: blindBox },+ ]);+ } else {+ expect(vault.sealValue.mock.calls.map((call) => call[0])).toEqual(['GITHUB_LOGIN.username', 'GITHUB_LOGIN', 'GITHUB_LOGIN.totp']);+ expect(payload.sealed).toEqual(envelope);+ expect(payload.establishing_vmk).toBe(true);+ expect(payload.authz_factor_registration).toEqual({ challenge_id: 'setup' });+ expect(payload.fields).toEqual([+ { name: 'username', record: 'GITHUB_LOGIN.username', sealed: envelope },+ { name: 'totp', record: 'GITHUB_LOGIN.totp', sealed: envelope },+ ]);+ expect(vault.afterCreated).toHaveBeenCalledOnce();+ }+});++it('keeps the legacy single-value create payload until fields are added', async () => {+ render(form(<VaultSecretForm fixedName="TOKEN" onCancel={vi.fn()} onCreated={vi.fn()} />));+ fireEvent.change(screen.getByPlaceholderText(en.vaults.dialog.valuePlaceholder), { target: { value: 'token' } });+ const submit = screen.getByRole('button', { name: 'Save & let the agent continue' }) as HTMLButtonElement;+ await waitFor(() => expect(submit.disabled).toBe(false));+ fireEvent.click(submit);+ await waitFor(() => expect(api.createVaultSecret).toHaveBeenCalledOnce());+ expect(api.createVaultSecret.mock.calls[0][0]).not.toHaveProperty('fields');+ expect(api.createVaultSecret.mock.calls[0][0]).not.toHaveProperty('default_field');+});++it('preserves a selected file instead of silently switching it to empty field rows', async () => {+ const { container } = render(form(<VaultSecretForm fixedName="TOKEN" onCancel={vi.fn()} onCreated={vi.fn()} />));+ fireEvent.click(screen.getByRole('radio', { name: 'File' }));+ const file = new File(['secret bytes'], 'credential.bin');+ fireEvent.change(container.querySelector('input[type="file"]')!, { target: { files: [file] } });+ expect(screen.getByText('credential.bin')).toBeTruthy();+ const add = screen.getByRole('button', { name: 'Add field' }) as HTMLButtonElement;+ const template = screen.getByRole('button', { name: 'Login template' }) as HTMLButtonElement;+ expect(add.disabled).toBe(true);+ expect(template.disabled).toBe(true);+ fireEvent.click(add);+ fireEvent.click(template);+ expect(screen.getByText('credential.bin')).toBeTruthy();+ expect(screen.getByText(en.vaults.fields.singleFile)).toBeTruthy();+ expect(screen.queryByLabelText('Field 1 name')).toBeNull();+});++it('seeds provision rows once, validates duplicate names, and permits removing extra rows', async () => {+ const spec = { fields: ['username', 'password', 'totp'], default_field: 'password' };+ const props = { fixedName: 'LOGIN', provisionRequestId: 'request', onCancel: vi.fn(), onCreated: vi.fn() };+ const { rerender } = render(form(<VaultSecretForm {...props} requestSpec={spec} />));+ change('Value for username', '用户');+ change('Value for password', 'secret');+ fireEvent.click(screen.getByRole('button', { name: 'Remove totp' }));+ rerender(form(<VaultSecretForm {...props} requestSpec={{ ...spec }} />));+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('用户');+ expect(screen.queryByLabelText('Value for totp')).toBeNull();+ change('Field 1 name', 'password');+ const submit = screen.getByRole('button', { name: 'Save & let the agent continue' }) as HTMLButtonElement;+ expect(submit.disabled).toBe(true);+ change('Field 1 name', 'user_name');+ await waitFor(() => expect(submit.disabled).toBe(false));+ fireEvent.click(submit);+ await waitFor(() => expect(api.createVaultSecret).toHaveBeenCalledOnce());+ expect(api.createVaultSecret.mock.calls[0][0].fields).toEqual([+ { name: 'user_name', record: 'LOGIN.user_name', blind_box: blindBox },+ ]);+});++it('does not overwrite edited metadata when a refreshed secret object arrives', () => {+ const first: VaultSecret = {+ name: 'LOGIN',+ default_field: 'password',+ fields: ['password', 'username'],+ kind: 'static',+ protection: 'standard',+ signer_kind: null,+ source: 'user',+ tags: [],+ policy: {},+ description: 'server description',+ last_used_at: null,+ use_count: 0,+ created_at: 'created',+ updated_at: 'version-1',+ };+ const refreshed = { ...first, description: 'new server description', updated_at: 'version-2' };+ const props = { onCancel: vi.fn(), onCreated: vi.fn(), editSecret: first };+ const { rerender } = render(form(<VaultSecretForm {...props} />));+ const description = screen.getByLabelText('Description') as HTMLInputElement;+ fireEvent.change(description, { target: { value: 'local unsaved description' } });+ rerender(form(<VaultSecretForm {...props} editSecret={refreshed} />));+ expect((screen.getByLabelText('Description') as HTMLInputElement).value).toBe('local unsaved description');+});diff --git a/ui/src/components/ui/vault-secret-form.tsx b/ui/src/components/ui/vault-secret-form.tsxindex fbc44934f..b54706ba7 100644--- a/ui/src/components/ui/vault-secret-form.tsx+++ b/ui/src/components/ui/vault-secret-form.tsx@@ -8,6 +8,7 @@ import {FileText,Loader2,Lock,+ Plus,RefreshCw,Server,ShieldCheck,@@ -24,6 +25,7 @@ import {type SigningAddresses,type VaultRequestSpec,type VaultSecret,+ type VaultCreatePayload,type VaultWebAuthnRegistrationPayload,} from '@/context/ApiContext';import type { VaultSandboxSealResult } from '@/lib/vaultSandboxClient';@@ -38,7 +40,9 @@ import {type ProtectedRecordEnvelope,type SigningKeyMaterial,} from '@/lib/vaultCrypto';+import { vaultErrorMessage } from '@/lib/vaultErrors';import { useProtectedVault } from '@/lib/useProtectedVault';+import { MAX_VAULT_FIELDS, VAULT_FIELD_PATTERN, vaultRecordName } from '@/lib/vaultFields';import { openVaultsInBrowser } from '@/lib/vaultBrowserHandoff';import { Badge } from './badge';import { Button } from './button';@@ -49,10 +53,12 @@ import { Switch } from './switch';import { TagInput } from './tag-input';import { Textarea } from './textarea';import { VaultProtectedUnlock } from './vault-protected-unlock';+import { VaultSecretFieldsEditor } from './vault-secret-fields-editor';type VaultKind = 'static' | 'keypair';type FetchAuthMode = 'bearer' | 'header' | 'query';type StaticSecretSource = 'text' | 'file';+type FieldDraft = { name: string; value: string };const AVAULT_P2_MIN_VERSION = '0.1.3';const MAX_SECRET_FILE_BYTES = 1024 * 1024;@@ -132,7 +138,7 @@ export const VaultSecretForm: React.FC<{provisionRequestId?: string | null;requestSpec?: VaultRequestSpec | null;treatExistingAsFulfilled?: boolean;- /** When set, the form is in value-free edit mode for this existing secret. */+ /** When set, metadata and individual field values can be edited. */editSecret?: VaultSecret | null;/** Called after a successful metadata edit (edit mode only). */onSaved?: (name: string) => void;@@ -155,6 +161,9 @@ export const VaultSecretForm: React.FC<{const api = useApi();const [name, setName] = useState(fixedName ?? '');const [value, setValue] = useState('');+ const [fieldRows, setFieldRows] = useState<FieldDraft[] | null>(null);+ const [defaultFieldIndex, setDefaultFieldIndex] = useState(0);+ const [fieldEditBusy, setFieldEditBusy] = useState(false);const staticValueRef = useRef('');const setStaticValue = useCallback((next: string) => {staticValueRef.current = next;@@ -289,13 +298,23 @@ export const VaultSecretForm: React.FC<{if (requestSpec.policy?.allowed_hosts) setAllowHosts(requestSpec.policy.allowed_hosts);if (requestSpec.policy?.auth?.type) setFetchAuthMode(requestSpec.policy.auth.type);if (requestSpec.policy?.auth?.name) setFetchAuthName(requestSpec.policy.auth.name);+ if (requestSpec.fields?.length) {+ setFieldRows(requestSpec.fields.map((field) => ({ name: field, value: '' })));+ setDefaultFieldIndex(Math.max(0, requestSpec.fields.indexOf(requestSpec.default_field ?? requestSpec.fields[0])));+ }}, [requestSpec, provisionRequestId]);// Edit mode: seed editable metadata from the existing secret. Name / kind / protection are// shown read-only (not seeded into editable controls); the value is never loaded; always_ask// is neither seeded nor emitted — the backend preserves it (storage.update_secret_metadata).+ const seededEditSecretRef = useRef<string | null>(null);useEffect(() => {- if (!editSecret) return;+ if (!editSecret) {+ seededEditSecretRef.current = null;+ return;+ }+ if (seededEditSecretRef.current === editSecret.name) return;+ seededEditSecretRef.current = editSecret.name;setKind(editSecret.kind === 'keypair' ? 'keypair' : 'static');setProtection(editSecret.protection === 'protected' ? 'protected' : 'standard');const parts = partitionTags(editSecret.tags);@@ -310,6 +329,7 @@ export const VaultSecretForm: React.FC<{const p2Ready = useMemo(() => avaultP2Ready(avaultDep), [avaultDep]);const secretName = (fixedName ?? name).trim();+ const secretNameValid = /^[A-Za-z_][A-Za-z0-9_]*$/.test(secretName);const protectedCreateReady = protectedVault.status === 'unlocked';const isKeypair = kind === 'keypair';const isProvision = Boolean(fixedName);@@ -365,7 +385,10 @@ export const VaultSecretForm: React.FC<{};}, [signingKey, api]);- const staticValueReady = staticSource === 'file' ? selectedFile != null && selectedFile.size > 0 : Boolean(value);+ const staticValueReady = fieldRows+ ? fieldRows.every((field) => field.value && VAULT_FIELD_PATTERN.test(field.name)) &&+ new Set(fieldRows.map((field) => field.name)).size === fieldRows.length+ : staticSource === 'file' ? selectedFile != null && selectedFile.size > 0 : Boolean(value);const valueReady = isKeypair? // Protected keypair must be generated in-sandbox first (below); standard keypair needs the// locally-built signing key. Static readiness is the entered/selected value.@@ -374,8 +397,8 @@ export const VaultSecretForm: React.FC<{: signingKey != null: staticValueReady;const canSubmit = isEdit- ? !submitting- : Boolean(secretName && valueReady) &&+ ? !submitting && !fieldEditBusy+ : Boolean(secretNameValid && valueReady) &&!submitting &&// Block submit while a protected keypair is (re)generating in the sandbox, so the user can't// submit the previous envelope mid-ceremony and persist a key they're actively replacing.@@ -390,6 +413,7 @@ export const VaultSecretForm: React.FC<{const clearStaticValue = useCallback(() => {staticValueRef.current = '';setValue('');+ setFieldRows((rows) => rows?.map((row) => ({ ...row, value: '' })) ?? null);clearSelectedFile();}, [clearSelectedFile]);@@ -469,7 +493,7 @@ export const VaultSecretForm: React.FC<{// here. R1 semantics — silent while unlocked (the form's gate covers the locked case). Regenerate// just calls again and discards the previous envelope.const generateProtectedKeypair = async () => {- if (!secretName || generatingKeypair) return;+ if (!secretNameValid || generatingKeypair) return;const gen = (keypairGenRef.current += 1);setGeneratingKeypair(true);setKeypairError(null);@@ -556,7 +580,7 @@ export const VaultSecretForm: React.FC<{});const result = await api.updateVaultSecret(editSecret.name, patch, { handleError: false });if (!result.ok) {- setError(result.message || t('vaults.dialog.errors.updateFailed'));+ setError(vaultErrorMessage(t, result, t('vaults.dialog.errors.updateFailed')));return;}onSaved?.(editSecret.name);@@ -606,7 +630,32 @@ export const VaultSecretForm: React.FC<{let establishingVmk = false;let authzFactorRegistration: Awaited<ReturnType<typeof protectedVault.sealValue>>['authzFactorRegistration'];let protectedPublicMeta: Record<string, unknown> | undefined;- if (protection === 'protected') {+ let extraFields: VaultCreatePayload['fields'];+ if (!isKeypair && fieldRows) {+ extraFields = [];+ const defaultField = fieldRows[defaultFieldIndex].name;+ const pubkey = protection === 'standard' ? await api.getVaultPubkey() : null;+ let defaultCrypto: typeof cryptoFields | undefined;+ for (const [index, row] of fieldRows.entries()) {+ const record = vaultRecordName(secretName, row.name, defaultField);+ let fieldCrypto: typeof cryptoFields;+ if (protection === 'protected') {+ const valueRef = { current: row.value };+ const sealed = await protectedVault.sealValue(record, 'static', {+ valueRef,+ clear: () => setFieldRows((rows) => rows?.map((field, i) => i === index ? { ...field, value: '' } : field) ?? null),+ });+ fieldCrypto = { sealed: sealed.envelope };+ establishingVmk ||= sealed.establishingVmk;+ authzFactorRegistration ??= sealed.authzFactorRegistration;+ } else {+ fieldCrypto = { blind_box: await sealBlindBox(row.value, pubkey!, standardCreateBlindBoxContext(record)) };+ }+ if (index === defaultFieldIndex) defaultCrypto = fieldCrypto;+ else extraFields.push({ name: row.name, record, ...fieldCrypto });+ }+ cryptoFields = defaultCrypto!;+ } else if (protection === 'protected') {if (isKeypair) {// Keypair was already sealed in-sandbox by "Generate key" (protocol v2 §7.2). Submit the// held envelope + public metadata; no second seal, and the private key never existed here.@@ -657,6 +706,7 @@ export const VaultSecretForm: React.FC<{...base,...(protectedPublicMeta ? { kind: 'keypair', signer_kind: 'local', public_meta: protectedPublicMeta } : {}),...cryptoFields,+ ...(!isKeypair && fieldRows ? { default_field: fieldRows[defaultFieldIndex].name, fields: extraFields } : {}),...(establishingVmk? {establishing_vmk: true,@@ -682,7 +732,7 @@ export const VaultSecretForm: React.FC<{setError(t('vaults.protectedUnlock.errors.alreadyInitialized'));return;}- throw new Error(created.message || created.code || t('vaults.request.saveFailed'));+ throw new Error(vaultErrorMessage(t, created, t('vaults.request.saveFailed')));}if (protection === 'protected') protectedVault.afterCreated();clearStaticValue();@@ -706,7 +756,7 @@ export const VaultSecretForm: React.FC<{} else if (err instanceof ApiError && err.code === 'secret_name_case_conflict') {setError(err.message || t('vaults.dialog.errors.secretNameCaseConflict'));} else {- setError(err instanceof Error ? err.message : String(err));+ setError(vaultErrorMessage(t, err, t('vaults.request.saveFailed')));}} finally {fileBytesToWipe?.fill(0);@@ -804,6 +854,70 @@ export const VaultSecretForm: React.FC<{</div>);+ const staticFields = (+ <div className="flex flex-col gap-2">+ {fieldRows ? (+ <div className="flex flex-col gap-3">+ {fieldRows.map((field, index) => (+ <div key={index} className="flex flex-col gap-2 rounded-lg border border-border p-3">+ <div className="flex items-center gap-2">+ <Input+ value={field.name}+ onChange={(event) => setFieldRows((rows) => rows!.map((row, i) => i === index ? { ...row, name: event.target.value } : row))}+ aria-label={t('vaults.fields.name', { index: index + 1 })}+ placeholder={t('vaults.fields.namePlaceholder')}+ pattern={VAULT_FIELD_PATTERN.source}+ maxLength={64}+ required+ disabled={submitting}+ className="min-w-0 font-mono"+ />+ <label className="flex shrink-0 items-center gap-1 text-xs text-muted">+ <input type="radio" name="default-field" checked={index === defaultFieldIndex} disabled={submitting}+ onChange={() => setDefaultFieldIndex(index)} />+ {t('vaults.fields.default')}+ </label>+ <Button type="button" variant="ghost" size="icon" disabled={submitting || index === defaultFieldIndex}+ aria-label={t('vaults.fields.remove', { field: field.name })}+ onClick={() => {+ setFieldRows((rows) => rows!.filter((_, i) => i !== index));+ if (index < defaultFieldIndex) setDefaultFieldIndex(defaultFieldIndex - 1);+ }}>+ <X className="size-4" />+ </Button>+ </div>+ <Input type="password" value={field.value} autoComplete="off" spellCheck={false} required disabled={submitting}+ aria-label={t('vaults.fields.value', { field: field.name || index + 1 })}+ placeholder={t('vaults.dialog.valuePlaceholder')}+ onChange={(event) => setFieldRows((rows) => rows!.map((row, i) => i === index ? { ...row, value: event.target.value } : row))} />+ </div>+ ))}+ <span className="text-[11px] text-muted-foreground">{t('vaults.fields.namesHelp')}</span>+ </div>+ ) : valueField}+ <div className="flex gap-2">+ <Button type="button" variant="ghost" size="sm" disabled={submitting || staticSource === 'file' || (fieldRows?.length ?? 1) >= MAX_VAULT_FIELDS}+ onClick={() => {+ setFieldRows((rows) => [...(rows ?? [{ name: 'value', value }]), { name: '', value: '' }]);+ setStaticValue('');+ setStaticSource('text');+ clearSelectedFile();+ }}>+ <Plus className="size-3.5" />{t('vaults.fields.add')}+ </Button>+ {!fieldRows && <Button type="button" variant="ghost" size="sm" disabled={submitting || staticSource === 'file'}+ onClick={() => {+ setFieldRows([{ name: 'username', value: '' }, { name: 'password', value }, { name: 'totp', value: '' }]);+ setDefaultFieldIndex(1);+ setStaticValue('');+ setStaticSource('text');+ clearSelectedFile();+ }}>{t('vaults.fields.loginTemplate')}</Button>}+ </div>+ {staticSource === 'file' && <span className="text-[11px] text-muted-foreground">{t('vaults.fields.singleFile')}</span>}+ </div>+ );+const fetchAuthPolicyFields = (<div className="flex flex-col gap-1.5"><span className={FIELD_LABEL}>{t('vaults.dialog.fetchAuth')}</span>@@ -1003,9 +1117,7 @@ export const VaultSecretForm: React.FC<{</div>);- // ---- Edit mode — value-free metadata edit of an existing secret --------------------- // Name / kind / protection / value are immutable and shown read-only; only description, tags- // (incl. `skill:` tags) and — for a static secret — the fetch proxy policy are editable.+ // Field writes save independently; the form submit updates shared metadata.if (isEdit && editSecret) {return (<form className={cn('flex min-w-0 flex-col gap-4', className)} onSubmit={onSubmit}>@@ -1027,6 +1139,7 @@ export const VaultSecretForm: React.FC<{<Lock className="size-3 shrink-0" />{t('vaults.edit.lockedHint')}</p>+ {!isKeypair && <VaultSecretFieldsEditor key={editSecret.name} secret={editSecret} disabled={submitting} onBusyChange={setFieldEditBusy} />}<label className="flex flex-col gap-1.5"><span className={FIELD_LABEL}>{t('vaults.dialog.description')}</span>@@ -1046,7 +1159,7 @@ export const VaultSecretForm: React.FC<{)}<div className="mt-1 flex justify-end gap-2">- <Button type="button" variant="ghost" onClick={onCancel} disabled={submitting}>+ <Button type="button" variant="ghost" onClick={onCancel} disabled={submitting || fieldEditBusy}>{cancelLabel ?? t('vaults.dialog.cancel')}</Button><Button type="submit" disabled={!canSubmit}>@@ -1076,11 +1189,11 @@ export const VaultSecretForm: React.FC<{</div>{!isKeypair && (- <label className="flex flex-col gap-1.5">+ <div className="flex flex-col gap-1.5"><span className={FIELD_LABEL}>{t('vaults.dialog.value')}</span>- {valueField}+ {staticFields}<span className="text-[11px] text-muted-foreground">{t('vaults.dialog.provisionValueHelp')}</span>- </label>+ </div>)}<label className="flex flex-col gap-1.5">@@ -1139,6 +1252,8 @@ export const VaultSecretForm: React.FC<{setSigningError(null);} else {clearStaticValue();+ setFieldRows(null);+ setDefaultFieldIndex(0);}// A sandbox-sealed protected keypair is bound to its kind; switching kind invalidates it.clearProtectedKeypair();@@ -1172,10 +1287,10 @@ export const VaultSecretForm: React.FC<{{/* Value (static) or signing-key builder (keypair) */}{!isKeypair && (- <label className="flex flex-col gap-1.5">+ <div className="flex flex-col gap-1.5"><span className={FIELD_LABEL}>{t('vaults.dialog.value')}</span>- {valueField}- </label>+ {staticFields}+ </div>)}{isKeypair && protection === 'standard' && (@@ -1285,7 +1400,7 @@ export const VaultSecretForm: React.FC<{<Buttontype="button"variant="secondary"- disabled={submitting || generatingKeypair || !secretName}+ disabled={submitting || generatingKeypair || !secretNameValid}onClick={() => void generateProtectedKeypair()}>{generatingKeypair ? <Loader2 className="size-4 animate-spin" /> : <RefreshCw className="size-4" />}diff --git a/ui/src/components/workbench/VaultsPage.test.tsx b/ui/src/components/workbench/VaultsPage.test.tsxindex 222e40d8d..433b51084 100644--- a/ui/src/components/workbench/VaultsPage.test.tsx+++ b/ui/src/components/workbench/VaultsPage.test.tsx@@ -7,12 +7,15 @@ import userEvent from '@testing-library/user-event';import { MemoryRouter } from 'react-router-dom';import { InstanceAuthorizationContext } from '../../context/InstanceAuthorizationContext';+import { ApiError } from '../../context/ApiContext';import { OWNER_INSTANCE_CAPABILITIES } from '../../lib/sessionInfo';+import zh from '../../i18n/zh.json';import { VaultsPage } from './VaultsPage';type WorkbenchEventHandlers = { onVaultsUpdated?: (data: unknown) => void };const eventHandlers = vi.hoisted(() => [] as WorkbenchEventHandlers[]);+const testTranslation = vi.hoisted(() => ({ locale: 'keys' as 'keys' | 'zh' }));const api = vi.hoisted(() => ({connectWorkbenchEvents: vi.fn(() => () => undefined),createVaultRevealContext: vi.fn(),@@ -59,9 +62,18 @@ vi.mock('../../lib/useProtectedVault', () => ({useVaultLock: () => ({ unlocked: false, remainingMs: 0, lockNow: vi.fn() }),}));-vi.mock('react-i18next', () => ({- useTranslation: () => ({ t: (key: string) => key }),-}));+vi.mock('react-i18next', async () => {+ const { default: catalog } = await import('../../i18n/zh.json');+ const localized: Record<string, string> = {+ 'errors.fields_corrupt': catalog.errors.fields_corrupt,+ 'vaults.reveal.errors.contextFailed': catalog.vaults.reveal.errors.contextFailed,+ };+ return {+ useTranslation: () => ({+ t: (key: string) => testTranslation.locale === 'zh' ? localized[key] ?? key : key,+ }),+ };+});vi.mock('./CapabilityTabs', () => ({CapabilityTabs: () => <div data-testid="capability-tabs" />,@@ -76,10 +88,20 @@ vi.mock('./WorkbenchPageHeader', () => ({),}));-function renderPage(context = remoteOwner) {+vi.mock('../ui/vault-secret-dialog', () => ({+ VaultSecretDialog: ({+ open,+ editSecret,+ }: {+ open: boolean;+ editSecret?: { name: string; updated_at: string } | null;+ }) => open ? <div data-testid="vault-edit-dialog">{editSecret?.name}:{editSecret?.updated_at}</div> : null,+}));++function renderPage(context = remoteOwner, initialEntries = ['/vaults']) {return render(<InstanceAuthorizationContext.Provider value={context}>- <MemoryRouter initialEntries={['/vaults']}>+ <MemoryRouter initialEntries={initialEntries}><VaultsPage /></MemoryRouter></InstanceAuthorizationContext.Provider>,@@ -105,6 +127,7 @@ beforeEach(() => {afterEach(() => {cleanup();+ testTranslation.locale = 'keys';vi.clearAllMocks();vi.restoreAllMocks();});@@ -126,6 +149,19 @@ describe('VaultsPage remote audit history', () => {expect(await screen.findByText('alpha')).toBeTruthy();});+ it('shows a single custom field label without offering a field selector', async () => {+ api.listVaultSecrets.mockResolvedValue({+ secrets: [{+ name: 'LOGIN', default_field: 'password', fields: ['password'], kind: 'static', protection: 'standard',+ signer_kind: null, source: 'user', tags: [], policy: {}, last_used_at: null, use_count: 0,+ created_at: 'created', updated_at: 'version-1',+ }],+ });+ renderPage();+ expect(await screen.findByText(/password/)).toBeTruthy();+ expect(screen.queryByRole('combobox')).toBeNull();+ });+it('shows Vault management controls to an Editor', async () => {renderPage(activeOrgMember);@@ -134,6 +170,39 @@ describe('VaultsPage remote audit history', () => {});});+describe('VaultsPage edit metadata freshness', () => {+ it('passes the refreshed list entry to an already-open edit dialog', async () => {+ const original = {+ name: 'LOGIN',+ default_field: 'password',+ fields: ['password', 'username'],+ kind: 'static',+ protection: 'standard',+ signer_kind: null,+ source: 'user',+ tags: [],+ policy: {},+ last_used_at: null,+ use_count: 0,+ created_at: 'created',+ updated_at: 'version-1',+ };+ const refreshed = { ...original, updated_at: 'version-2' };+ api.listVaultSecrets.mockResolvedValue({ secrets: [original] });+ renderPage();+ await screen.findByText('LOGIN');+ fireEvent.click(await screen.findByRole('button', { name: 'vaults.rowActions' }));+ fireEvent.click(screen.getByRole('menuitem', { name: 'vaults.editSecret' }));+ expect((await screen.findByTestId('vault-edit-dialog')).textContent).toBe('LOGIN:version-1');++ api.listVaultSecrets.mockResolvedValue({ secrets: [refreshed] });+ await act(async () => {+ for (const handler of [...eventHandlers]) handler.onVaultsUpdated?.({});+ });+ expect((await screen.findByTestId('vault-edit-dialog')).textContent).toBe('LOGIN:version-2');+ });+});+// PERMISSIONS-016 — `vaults.updated` is admitted at the Editor tier that owns// the endpoint it announces, and below runtime management the controller reduces// the frame to its type alone. The pending-requests list is the consumer that@@ -230,6 +299,38 @@ describe('VaultsPage protected reveal', () => {expect(api.createVaultRevealContext).toHaveBeenCalledTimes(fetches);});+ it('shows the localized corruption warning on a row while keeping default reveal available', async () => {+ testTranslation.locale = 'zh';+ api.listVaultSecrets.mockResolvedValue({+ secrets: [{ ...protectedSecret('alpha'), fields_state: 'corrupt' }],+ });+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { secret_name: 'alpha' }, envelope });+ await openMenu();+ expect((await screen.findByRole('alert')).textContent).toBe(zh.errors.fields_corrupt);+ expect(screen.getByRole('menuitem', { name: 'vaults.reveal.show' })).toBeTruthy();+ });++ it.each(['response', 'exception'] as const)('localizes a reveal context failure from a %s in Chinese', async (failure) => {+ testTranslation.locale = 'zh';+ if (failure === 'response') {+ api.createVaultRevealContext.mockResolvedValue({+ ok: false,+ code: 'fields_corrupt',+ message: 'English service detail',+ });+ } else {+ api.createVaultRevealContext.mockRejectedValue(+ new ApiError('English service detail', 409, 'fields_corrupt'),+ );+ }+ const popup = { closed: false, close: vi.fn() };+ vi.spyOn(window, 'open').mockReturnValue(popup as unknown as Window);+ await openMenu();+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());+ fireEvent.click(showValue());+ await vi.waitFor(() => expect(showToast).toHaveBeenCalledWith(zh.errors.fields_corrupt, 'warning'));+ });+it('keeps Show value waiting while the context or the sandbox client are not ready', async () => {let answer: () => void = () => undefined;api.createVaultRevealContext.mockImplementation(@@ -265,6 +366,97 @@ describe('VaultsPage protected reveal', () => {expect(revealProtectedValue.mock.calls[0][1]).toEqual({ secret_name: 'beta' });});+ // A field switch needs its own prepared context. The single-secret cases above cannot detect+ // displaying the default envelope for an extra field, or using NAME.password as a default record.+ it.each([+ { field: 'password', record: 'alpha' },+ { field: 'username', record: 'alpha.username' },+ ])('reveals $field with its own context and canonical record', async ({ field, record }) => {+ api.listVaultSecrets.mockResolvedValue({+ secrets: [{ ...protectedSecret('alpha'), default_field: 'password', fields: ['password', 'username'] }],+ });+ api.createVaultRevealContext.mockImplementation(async (_name, payload) => ({+ ok: true, context: { field: payload.field }, envelope,+ }));+ await openMenu();+ fireEvent.change(screen.getByRole('combobox', { name: 'vaults.fields.revealField' }), { target: { value: field } });+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenLastCalledWith(+ 'alpha', { session_label: 'vaults.title', field },+ ));+ await clickShowValue();+ expect(revealProtectedValue.mock.calls[0][0].name).toBe(record);+ expect(revealProtectedValue.mock.calls[0][1]).toEqual({ field });+ });++ it('shows a stale handoff field without preparing or revealing the default field', async () => {+ api.listVaultSecrets.mockResolvedValue({+ secrets: [{ ...protectedSecret('alpha'), default_field: 'password', fields: ['password'] }],+ });+ renderPage(remoteOwner, ['/vaults?reveal=alpha&field=username']);++ expect((await screen.findByRole('alert')).textContent).toBe('vaults.reveal.errors.staleField');+ expect(api.createVaultRevealContext).not.toHaveBeenCalled();+ expect(revealProtectedValue).not.toHaveBeenCalled();+ });++ it('keeps a disappearing active field stale without preparing the default field', async () => {+ const initial = { ...protectedSecret('alpha'), default_field: 'password', fields: ['password', 'username'] };+ api.listVaultSecrets.mockResolvedValue({ secrets: [initial] });+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { field: 'ready' }, envelope });+ renderPage();+ const user = userEvent.setup();+ await user.click((await screen.findByRole('button', { name: 'vaults.rowActions' })));+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());+ fireEvent.change(screen.getByRole('combobox', { name: 'vaults.fields.revealField' }), { target: { value: 'username' } });+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(2));+ const preparedBeforeRefresh = api.createVaultRevealContext.mock.calls.length;++ api.listVaultSecrets.mockResolvedValue({+ secrets: [{ ...initial, fields: ['password'] }],+ });+ await act(async () => {+ for (const handler of [...eventHandlers]) handler.onVaultsUpdated?.({});+ });++ expect((await screen.findByRole('alert')).textContent).toBe('vaults.reveal.errors.staleField');+ expect(api.createVaultRevealContext).toHaveBeenCalledTimes(preparedBeforeRefresh);+ });++ it('refreshes a prepared extra-field context when only the default label changes', async () => {+ const entry = { ...protectedSecret('alpha'), default_field: 'password', fields: ['password', 'username'] };+ api.listVaultSecrets.mockResolvedValue({ secrets: [entry] });+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { label: 'password' }, envelope });+ await openMenu();+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());+ fireEvent.change(screen.getByRole('combobox', { name: 'vaults.fields.revealField' }), { target: { value: 'username' } });+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(2));+ api.listVaultSecrets.mockResolvedValue({ secrets: [{ ...entry, default_field: 'credential', fields: ['credential', 'username'] }] });+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { label: 'credential' }, envelope });+ await act(async () => {+ for (const handler of eventHandlers) handler.onVaultsUpdated?.({ scope: 'secret', secret_name: 'alpha' });+ });+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(3));+ await clickShowValue();+ expect(revealProtectedValue.mock.calls[0][1]).toEqual({ label: 'credential' });+ });++ it('prepares the replacement envelope when an open secret changes version', async () => {+ let version = 'old';+ api.createVaultRevealContext.mockImplementation(async () => ({ ok: true, context: { version }, envelope }));+ await openMenu();+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());+ version = 'new';+ api.listVaultSecrets.mockResolvedValue({+ secrets: [{ ...protectedSecret('alpha'), updated_at: '2026-10-13T12:00:00Z' }],+ });+ await act(async () => {+ for (const handler of eventHandlers) handler.onVaultsUpdated?.({ scope: 'secret', secret_name: 'alpha' });+ });+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(2));+ await clickShowValue();+ expect(revealProtectedValue.mock.calls[0][1]).toEqual({ version: 'new' });+ });+it('refreshes the context while the menu stays open, so the click fetches nothing', async () => {let fetched = 0;api.createVaultRevealContext.mockImplementation(async () => ({ ok: true, context: { fetch: ++fetched }, envelope }));diff --git a/ui/src/components/workbench/VaultsPage.tsx b/ui/src/components/workbench/VaultsPage.tsxindex 6f0ecb598..9f107b98a 100644--- a/ui/src/components/workbench/VaultsPage.tsx+++ b/ui/src/components/workbench/VaultsPage.tsx@@ -13,6 +13,8 @@ import { VaultLockIndicator } from '../ui/vault-lock-indicator';import { onPageReactivated } from '../../lib/pageActivity';import { cn } from '../../lib/utils';import { partitionTags } from '../../lib/vaultTags';+import { vaultDefaultField, vaultFieldFingerprint, vaultFieldNames, vaultHasNamedFieldShape, vaultRecordName } from '../../lib/vaultFields';+import { vaultErrorMessage } from '../../lib/vaultErrors';import {useApi,type VaultAuditEvent,@@ -62,19 +64,26 @@ const SecretRow: React.FC<{secret: VaultSecret;onEdit: (secret: VaultSecret) => void;onDelete: (secret: VaultSecret) => void;- onReveal: (secret: VaultSecret) => void;+ onReveal: (secret: VaultSecret, field: string) => void;+ revealField: string | null;+ onRevealFieldChange: (field: string) => void;canManage: boolean;menuOpen: boolean;onMenuOpenChange: (open: boolean) => void;/** The open menu's reveal context or sandbox client is not ready yet. */revealPreparing: boolean;-}> = ({ secret: s, onEdit, onDelete, onReveal, canManage, menuOpen, onMenuOpenChange: setMenuOpen, revealPreparing }) => {+}> = ({ secret: s, onEdit, onDelete, onReveal, revealField, onRevealFieldChange, canManage, menuOpen, onMenuOpenChange: setMenuOpen, revealPreparing }) => {const { t } = useTranslation();const isKeypair = s.kind === 'keypair';const isProtected = s.protection === 'protected';// Reveal is only meaningful for a protected static secret: its plaintext lives sealed and can be// shown in-sandbox. Standard values aren't sandbox-sealed, and a keypair has no plaintext value.const canReveal = isProtected && !isKeypair;+ const fields = vaultFieldNames(s);+ const selectedField = revealField === null+ ? vaultDefaultField(s)+ : fields.includes(revealField) ? revealField : null;+ const staleRevealField = canReveal && selectedField === null;// The sandbox reveal needs its authorization window, which only a browser can pair with.const revealInBrowser = canReveal && vaultPasskeyNeedsBrowser();// Skills are stored as reserved `skill:<name>` tags; render them as their own chips.@@ -124,7 +133,17 @@ const SecretRow: React.FC<{{s.description ? `${s.description} · ` : ''}{s.last_used_at ? t('vaults.used', { count: s.use_count }) : t('vaults.neverUsed')}</span>+ {s.fields_state === 'corrupt' && (+ <span role="alert" className="text-xs text-destructive-ink">{t('errors.fields_corrupt')}</span>+ )}{isKeypair && s.signing_addresses ? <SigningAddressList addresses={s.signing_addresses} className="mt-1" /> : null}+ {!isKeypair && vaultHasNamedFieldShape(s) && (+ <div className="flex flex-wrap gap-1">+ {fields.map((field) => <Badge key={field} variant="outline" className="font-mono">+ {field}{field === vaultDefaultField(s) ? ` · ${t('vaults.fields.default')}` : ''}+ </Badge>)}+ </div>+ )}</div>{canManage ? <div className="ml-auto"><Popover open={menuOpen} onOpenChange={setMenuOpen}>@@ -134,14 +153,30 @@ const SecretRow: React.FC<{</Button></PopoverTrigger><PopoverContent align="end" className="w-44 p-1" role="menu">- {revealInBrowser ? (+ {/* Choice-only: a single custom field is displayed above but needs no selector. */}+ {canReveal && fields.length > 1 && (+ <label className="flex flex-col gap-1 px-2.5 py-2 text-xs text-muted">+ {t('vaults.fields.revealField')}+ <select value={selectedField ?? ''} onChange={(event) => onRevealFieldChange(event.target.value)}+ className="rounded-md border border-border bg-surface px-2 py-1 font-mono text-foreground">+ {fields.map((field) => <option key={field} value={field}>{field}</option>)}+ </select>+ </label>+ )}+ {staleRevealField && (+ <p role="alert" className="px-2.5 py-2 text-xs text-destructive-ink">+ {t('vaults.reveal.errors.staleField')}+ </p>+ )}+ {!staleRevealField && revealInBrowser ? (<><buttontype="button"role="menuitem"onClick={() => {+ if (!selectedField) return;setMenuOpen(false);- openVaultsInBrowser({ kind: 'reveal', secretName: s.name });+ openVaultsInBrowser({ kind: 'reveal', secretName: s.name, field: selectedField });}}className="flex w-full items-center gap-2 rounded-md px-2.5 py-2 text-left text-sm text-foreground transition-colors hover:bg-surface-2">@@ -150,7 +185,7 @@ const SecretRow: React.FC<{</button><div className="my-1 h-px bg-border" /></>- ) : canReveal ? (+ ) : !staleRevealField && canReveal ? (<>{/* Reveal opens the value inside the sandbox frame; the plaintext is never returnedto Avibe. "Copy value" leads to the same sandbox card, where copying is the@@ -160,8 +195,9 @@ const SecretRow: React.FC<{role="menuitem"disabled={revealPreparing}onClick={() => {+ if (!selectedField) return;setMenuOpen(false);- onReveal(s);+ onReveal(s, selectedField);}}className="flex w-full items-center gap-2 rounded-md px-2.5 py-2 text-left text-sm text-foreground transition-colors hover:bg-surface-2 disabled:cursor-default disabled:opacity-50 disabled:hover:bg-transparent">@@ -173,8 +209,9 @@ const SecretRow: React.FC<{role="menuitem"disabled={revealPreparing}onClick={() => {+ if (!selectedField) return;setMenuOpen(false);- onReveal(s);+ onReveal(s, selectedField);}}className="flex w-full items-center gap-2 rounded-md px-2.5 py-2 text-left text-sm text-foreground transition-colors hover:bg-surface-2 disabled:cursor-default disabled:opacity-50 disabled:hover:bg-transparent">@@ -569,6 +606,7 @@ export const VaultsPage: React.FC = () => {const step = useMemo(() => readVaultBrowserStep(searchParams), [searchParams]);// The secret whose row menu is open; a reveal handed off from the desktop app reopens it.const [menuSecret, setMenuSecret] = useState<string | null>(null);+ const [menuField, setMenuField] = useState<string | null>(null);const clearStep = useCallback(() => {setSearchParams((prev) => withoutVaultBrowserStep(prev), { replace: true });@@ -585,6 +623,7 @@ export const VaultsPage: React.FC = () => {useEffect(() => {if (!canManage || step?.kind !== 'reveal' || !secrets.some((s) => s.name === step.secretName)) return;setMenuSecret(step.secretName);+ setMenuField(step.field ?? null);clearStep();}, [canManage, step, secrets, clearStep]);@@ -733,6 +772,16 @@ export const VaultsPage: React.FC = () => {const [deleteTarget, setDeleteTarget] = useState<VaultSecret | null>(null);const [editTarget, setEditTarget] = useState<VaultSecret | null>(null);+ const activeEditSecret = editTarget+ ? secrets.find((entry) => entry.name === editTarget.name) ?? editTarget+ : null;+ useEffect(() => {+ if (!canManage || step?.kind !== 'edit') return;+ const secret = secrets.find((entry) => entry.name === step.secretName);+ if (!secret) return;+ setEditTarget(secret);+ clearStep();+ }, [canManage, step, secrets, clearStep]);const onDelete = (secret: VaultSecret) => setDeleteTarget(secret);const onEdit = (secret: VaultSecret) => setEditTarget(secret);@@ -743,35 +792,47 @@ export const VaultsPage: React.FC = () => {// the daemon after the click (`usePreparedRequest`), so the open row menu keeps the context and the// sandbox client ready, and the click claims them.const requestRevealContext = useCallback(- (name: string) => api.createVaultRevealContext(name, { session_label: t('vaults.title') }),+ ({ name, field }: { name: string; field: string; version: string }) => api.createVaultRevealContext(name, { session_label: t('vaults.title'), field }),[api, t],);- const menuRevealName = useMemo(() => {+ const menuRevealKey = useMemo(() => {const secret = secrets.find((s) => s.name === menuSecret);- return secret?.protection === 'protected' && secret.kind !== 'keypair' && !vaultPasskeyNeedsBrowser() ? secret.name : null;- }, [secrets, menuSecret]);- const revealContext = usePreparedRequest(menuRevealName, requestRevealContext, revealContextIssued, PREPARED_REVEAL);- const revealSandboxReady = useVaultSandboxWarm(menuRevealName !== null);+ if (secret?.protection !== 'protected' || secret.kind === 'keypair' || vaultPasskeyNeedsBrowser()) return null;+ if (menuField !== null && !vaultFieldNames(secret).includes(menuField)) return null;+ return {+ name: secret.name,+ field: menuField ?? vaultDefaultField(secret),+ version: vaultFieldFingerprint(secret),+ };+ }, [secrets, menuSecret, menuField]);+ const revealContext = usePreparedRequest(menuRevealKey, requestRevealContext, revealContextIssued, PREPARED_REVEAL);+ const revealSandboxReady = useVaultSandboxWarm(menuRevealKey !== null);// Show and Copy wait for both, so their click never waits on either.const revealPreparing = !revealSandboxReady || revealContext.pending;const revealSecret = useCallback(- async (secret: VaultSecret) => {+ async (secret: VaultSecret, field: string) => {const authorizationWindow = openVaultAuthorizationWindow();try {- const res = await revealContext.claim(secret.name);- if (!res?.ok || !res.context) throw new Error(res?.message || t('vaults.reveal.errors.contextFailed'));+ const res = await revealContext.claim({ name: secret.name, field, version: vaultFieldFingerprint(secret) });+ if (!res?.ok || !res.context) {+ const message = vaultErrorMessage(t, res, t('vaults.reveal.errors.contextFailed'));+ const code = typeof res === 'object' && res !== null && 'code' in res && typeof res.code === 'string'+ ? res.code+ : null;+ throw Object.assign(new Error(message), code ? { code } : {});+ }// The sandbox needs the sealed record to open it. The daemon returns it alongside the signed// reveal context; if it's absent, surface a clear message rather than a cryptic sandbox error.if (!res.envelope) throw new Error(t('vaults.reveal.errors.unavailable'));const wrapMeta =typeof res.envelope.wrap_meta === 'string' ? res.envelope.wrap_meta : JSON.stringify(res.envelope.wrap_meta);await vault.revealProtectedValue(- { name: secret.name, kind: 'static', envelope: { ciphertext: res.envelope.ciphertext, nonce: res.envelope.nonce, wrap_meta: wrapMeta } },+ { name: vaultRecordName(secret.name, field, vaultDefaultField(secret)), kind: 'static', envelope: { ciphertext: res.envelope.ciphertext, nonce: res.envelope.nonce, wrap_meta: wrapMeta } },res.context,authorizationWindow?.id,);} catch (err: unknown) {- showToast(messageFromError(err), 'warning');+ showToast(vaultErrorMessage(t, err, t('vaults.reveal.errors.contextFailed')), 'warning');} finally {authorizationWindow?.close();}@@ -935,10 +996,15 @@ export const VaultsPage: React.FC = () => {onEdit={onEdit}onDelete={onDelete}onReveal={revealSecret}+ revealField={s.name === menuSecret ? menuField : null}+ onRevealFieldChange={setMenuField}canManage={canManage}menuOpen={s.name === menuSecret}- revealPreparing={s.name === menuRevealName && revealPreparing}- onMenuOpenChange={(open) => setMenuSecret(open ? s.name : null)}+ revealPreparing={s.name === menuRevealKey?.name && revealPreparing}+ onMenuOpenChange={(open) => {+ setMenuSecret(open ? s.name : null);+ setMenuField(null);+ }}/>))}</div>@@ -977,8 +1043,8 @@ export const VaultsPage: React.FC = () => {}}/> : null}{canManage ? <VaultSecretDialog- open={editTarget != null}- editSecret={editTarget}+ open={activeEditSecret != null}+ editSecret={activeEditSecret}onOpenChange={(o) => {if (!o) setEditTarget(null);}}diff --git a/ui/src/context/ApiContext.tsx b/ui/src/context/ApiContext.tsxindex e9de3f840..e0b76f38b 100644--- a/ui/src/context/ApiContext.tsx+++ b/ui/src/context/ApiContext.tsx@@ -82,6 +82,11 @@ export type SigningAddresses = {export type VaultSecret = {name: string;+ /** Absent on legacy servers; the default record is always the bare secret name. */+ default_field?: string;+ fields?: string[];+ /** Present only when the stored extra-field section could not be read safely. */+ fields_state?: 'corrupt';/** Flat tag list; skill association is a reserved `skill:<name>` tag (see lib/vaultTags). */tags: string[];kind: string;@@ -134,6 +139,8 @@ export type VaultRequestSession = {export type VaultRequestSpec = {kind?: 'static';+ default_field?: string;+ fields?: string[];protection?: 'standard' | 'protected';description?: string;/** May already include `skill:<name>` tags; `links.skills` is a bare-name convenience mirror. */@@ -358,6 +365,8 @@ export type VaultWebAuthnRegistrationPayload = {export type VaultCreatePayload = {name: string;+ default_field?: string;+ fields?: VaultCreateFieldPayload[];protection?: 'standard' | 'protected';blind_box?: VaultBlindBox;sealed?: VaultSealedEnvelope;@@ -387,11 +396,28 @@ export type VaultCreatePayload = {* such as `always_ask`. Name / kind / protection / value are never editable through this path.*/export type VaultMetadataUpdatePayload = {+ default_field?: string;description?: string | null;tags?: string[];policy?: Record<string, unknown>;};+export type VaultFieldValuePayload = {+ /** Canonical record name bound into the envelope (NAME for the default field). */+ record: string;+ blind_box?: VaultBlindBox;+ sealed?: VaultSealedEnvelope;+ expected_updated_at?: string;+};++export type VaultCreateFieldPayload = {+ name: string;+ /** Canonical record name bound into this extra field's envelope. */+ record: string;+ blind_box?: VaultBlindBox;+ sealed?: VaultSealedEnvelope;+};+export type TunnelQualitySnapshot = {schema_version: 1 | 2;state: 'healthy' | 'degraded' | 'recovering' | 'unknown';@@ -806,7 +832,7 @@ export type ApiContextType = {updateVibeAgent: (name: string, payload: VibeAgentUpdatePayload) => Promise<{ ok: boolean; agent: VibeAgentFull }>;setDefaultVibeAgent: (name: string) => Promise<{ ok: boolean; default_agent_name: string; agent: VibeAgentBrief }>;removeVibeAgent: (name: string) => Promise<{ ok: boolean; code?: string; message?: string; references?: Record<string, number>; removed_agent?: string; archived_agent?: VibeAgentBrief; default_agent_name?: string | null }>;- listVaultSecrets: () => Promise<{ ok: boolean; secrets: VaultSecret[] }>;+ listVaultSecrets: (opts?: { cache?: boolean }) => Promise<{ ok: boolean; secrets: VaultSecret[] }>;getVaultVmk: () => Promise<VaultVmkResult>;getVaultPubkey: () => Promise<{ ok: boolean; public_key: string; fingerprint: string }>;getVaultAgentPubkey: () => Promise<{ ok: boolean; public_key: string; fingerprint: string }>;@@ -820,7 +846,7 @@ export type ApiContextType = {saveVaultSettings: (payload: Partial<VaultSettings>) => Promise<VaultSettingsResult>;createVaultRevealContext: (name: string,- payload?: { session_label?: string },+ payload?: { session_label?: string; field?: string },) => Promise<VaultRevealContextResult>;deriveSigningAddresses: (publicKey: string) => Promise<{ ok: boolean; addresses?: SigningAddresses; code?: string; message?: string }>;createVaultAuthzWebAuthnOptions: () => Promise<VaultWebAuthnRegistrationOptions>;@@ -829,6 +855,8 @@ export type ApiContextType = {) => Promise<{ ok: boolean; factor?: Record<string, unknown>; code?: string; message?: string }>;createVaultSecret: (payload: VaultCreatePayload, opts?: { handleError?: boolean }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;updateVaultSecret: (name: string, payload: VaultMetadataUpdatePayload, opts?: { handleError?: boolean }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;+ updateVaultSecretField: (name: string, field: string, payload: VaultFieldValuePayload, opts?: { handleError?: boolean }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;+ deleteVaultSecretField: (name: string, field: string, payload: { expected_updated_at: string }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;deleteVaultSecret: (name: string) => Promise<{ ok: boolean; removed?: boolean; code?: string; message?: string }>;getVaultProvisionRequest: (name: string,@@ -2527,12 +2555,12 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ children// absent page there means it vanished mid-session rather than never existed.const readShowPageJson = (path: string) => getJson(path, { expectedCodes: ['show_page_not_found'] });- const getCachedJson = (path: string, ttlMs = 1500, opts?: { handleError?: boolean }) => {+ const getCachedJson = (path: string, ttlMs = 1500, opts?: { cache?: boolean; handleError?: boolean }) => {// Best-effort callers (handleError: false) bypass the shared read cache so a// silently-failing request can't hand its suppressed-error promise to a// toast-enabled caller hitting the same path.- if (opts?.handleError === false) {- return getJson(path, opts);+ if (opts?.cache === false || opts?.handleError === false) {+ return getJson(path, { handleError: opts?.handleError });}const now = Date.now();const cached = readCacheRef.current.get(path);@@ -3284,7 +3312,11 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ children// ``getJson``/``postJson``. New mutating helpers should route through// requestJson/postJson/patchJson/deleteJson so successful mutations always// invalidate reusable GET promises.- const deleteJson = async (path: string, payload?: any) => {+ const deleteJson = async (+ path: string,+ payload?: any,+ opts?: { handleError?: boolean; expectedCodes?: readonly string[] },+ ) => {const { payloadJson } = await requestJson(path, {method: 'DELETE',...(payload === undefined@@ -3293,7 +3325,7 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ childrenheaders: { 'Content-Type': 'application/json' },body: JSON.stringify(payload),}),- });+ }, path, opts);return payloadJson;};@@ -3985,7 +4017,7 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ childrensetDefaultVibeAgent: (name) => postJson('/api/agents/default', { name }),removeVibeAgent: (name) => deleteJson(`/api/agents/${encodeURIComponent(name)}`),getVaultVmk: () => getCachedJson('/api/vault/vmk', 1500, { handleError: false }),- listVaultSecrets: () => getCachedJson('/api/vault/secrets', 1500),+ listVaultSecrets: (opts) => getCachedJson('/api/vault/secrets', 1500, opts),getVaultPubkey: () => getCachedJson('/api/vault/pubkey', 1500),getVaultAgentPubkey: () => getCachedJson('/api/vault/agent/pubkey', 1500),getVaultSandboxRootMetadata: () => getCachedJson('/api/vault/sandbox/root-metadata', 1500, { handleError: false }),@@ -4001,6 +4033,21 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ childrenregisterVaultAuthzWebAuthnFactor: (payload) => postJson('/api/vault/authz/factors/webauthn', payload),createVaultSecret: (payload, opts) => postJson('/api/vault/secrets', payload, opts),updateVaultSecret: (name, payload, opts) => patchJson(`/api/vault/secrets/${encodeURIComponent(name)}`, payload, opts),+ updateVaultSecretField: async (name, field, payload, opts) => {+ const path = `/api/vault/secrets/${encodeURIComponent(name)}/fields/${encodeURIComponent(field)}`;+ const { payloadJson } = await requestJson(path, {+ method: 'PUT',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify(payload),+ }, path, opts);+ return payloadJson;+ },+ deleteVaultSecretField: (name, field, payload) =>+ deleteJson(+ `/api/vault/secrets/${encodeURIComponent(name)}/fields/${encodeURIComponent(field)}`,+ payload,+ { handleError: false },+ ),deleteVaultSecret: (name) => deleteJson(`/api/vault/secrets/${encodeURIComponent(name)}`),getVaultProvisionRequest: (name, opts) =>getCachedJson(`/api/vault/provision-requests/${encodeURIComponent(name)}`, 1500, opts),diff --git a/ui/src/context/ApiContext.vault.test.tsx b/ui/src/context/ApiContext.vault.test.tsxnew file mode 100644index 000000000..1547ef980--- /dev/null+++ b/ui/src/context/ApiContext.vault.test.tsx@@ -0,0 +1,57 @@+/* @vitest-environment jsdom */+import { cleanup, renderHook } from '@testing-library/react';+import { createInstance } from 'i18next';+import { afterEach, beforeEach, expect, it, vi } from 'vitest';+import zh from '@/i18n/zh.json';++const apiFetch = vi.hoisted(() => vi.fn());+const showToast = vi.hoisted(() => vi.fn());+vi.mock('../lib/apiFetch', async (original) => ({+ ...await original<typeof import('../lib/apiFetch')>(), apiFetch,+}));+vi.mock('./ToastContext', () => ({ useToast: () => ({ showToast }) }));+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: i18n.t.bind(i18n) }) }));+import { ApiProvider, useApi } from './ApiContext';++const i18n = createInstance();+void i18n.init({ lng: 'zh', resources: { zh: { translation: zh } }, interpolation: { escapeValue: false } });+beforeEach(() => {+ apiFetch.mockReset();+ showToast.mockReset();+ vi.spyOn(console, 'error').mockImplementation(() => {});+});+afterEach(() => { cleanup(); vi.restoreAllMocks(); });++// The transport must send the version, not merely pass it to a mock API method.+it('sends the displayed field version in the DELETE request body', async () => {+ apiFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true })));+ const { result } = renderHook(useApi, { wrapper: ApiProvider });+ await result.current.deleteVaultSecretField('LOGIN', 'username', { expected_updated_at: 'editor-version' });+ const [path, request] = apiFetch.mock.calls.at(-1)!;+ expect(path).toBe('/api/vault/secrets/LOGIN/fields/username');+ expect(request.method).toBe('DELETE');+ expect(request.body).toBe(JSON.stringify({ expected_updated_at: 'editor-version' }));+});++it('keeps a stale field DELETE inline instead of showing a global toast', async () => {+ apiFetch.mockResolvedValue(new Response(JSON.stringify({+ ok: false,+ code: 'secret_conflict',+ message: 'stale field version',+ }), { status: 409 }));+ const { result } = renderHook(useApi, { wrapper: ApiProvider });+ await expect(result.current.deleteVaultSecretField('LOGIN', 'username', {+ expected_updated_at: 'editor-version',+ })).resolves.toMatchObject({ ok: false, code: 'secret_conflict' });+ expect(showToast).not.toHaveBeenCalled();+});++it.each([+ 'invalid_field_name', 'field_exists', 'field_not_found', 'too_many_fields',+ 'fields_not_supported', 'record_mismatch', 'secret_conflict', 'fields_corrupt',+] as const)('localizes the Web toast for %s instead of displaying the service English', async (code) => {+ apiFetch.mockResolvedValue(new Response(JSON.stringify({ code, message: 'English service detail' }), { status: 409 }));+ const { result } = renderHook(useApi, { wrapper: ApiProvider });+ await expect(result.current.createVaultSecret({ name: 'LOGIN' })).rejects.toMatchObject({ code, message: zh.errors[code] });+ expect(showToast).toHaveBeenCalledWith(zh.errors[code], 'error');+});diff --git a/ui/src/i18n/en.json b/ui/src/i18n/en.jsonindex 4f7462469..a979594f3 100644--- a/ui/src/i18n/en.json+++ b/ui/src/i18n/en.json@@ -2520,6 +2520,15 @@"retry": "Retry"},"errors": {+ "invalid_field_name": "Use 1–64 lowercase letters, digits or underscores for field names, starting with a letter.",+ "field_exists": "A field with this name already exists. Choose a different name.",+ "field_not_found": "This field no longer exists. Refresh the secret and choose one of its current fields.",+ "too_many_fields": "A secret can have at most 32 fields, including the default field.",+ "fields_corrupt": "This secret's stored field data is damaged. The default value remains available; field changes are disabled to preserve existing data.",+ "fields_not_supported": "Signing keys do not support named fields or default-field renaming.",+ "record_mismatch": "This field changed while you were saving. Refresh the secret and try again.",+ "secret_conflict": "This secret changed elsewhere. Review the refreshed fields and try again; your change was not saved.",+ "secret_not_found": "This secret no longer exists. Refresh the vault and choose another secret.","retry_not_available": "This notice cannot be retried. Send a message to continue.","retry_stale": "Newer work has already started. Send a message if you want to continue.","retry_busy": "The previous turn is still settling. Try again after it stops.",@@ -4974,18 +4983,45 @@"copy": "Copy value","showInBrowser": "Show in browser","errors": {+ "staleField": "This link points to a field that no longer exists. Open the secret and choose a current field.","contextFailed": "Couldn't prepare the reveal. Please try again.","unavailable": "Reveal isn't available for this secret yet."}},"saved": "Updated {{name}}",- "editSecret": "Edit info",+ "editSecret": "Edit secret","rowActions": "More actions","edit": {- "title": "Edit info",- "subtitle": "Info edits keep grants; fetch policy changes require new approval",+ "title": "Edit secret",+ "subtitle": "Value or fetch policy changes require new approval","lockedHint": "Name, kind and protection can't be changed"},+ "fields": {+ "title": "Fields",+ "name": "Field {{index}} name",+ "namePlaceholder": "field_name",+ "value": "Value for {{field}}",+ "default": "Default",+ "defaultName": "Default field name",+ "newName": "New field name",+ "newValue": "New field value",+ "add": "Add field",+ "loginTemplate": "Login template",+ "remove": "Remove {{field}}",+ "removeConfirm": "Remove this field and its value? Existing grants will expire.",+ "rename": "Rename",+ "save": "Save field",+ "saveNamed": "Save {{field}}",+ "saved": "Field saved",+ "draftsDropped": "Drafts for fields removed elsewhere were dropped: {{fields}}.",+ "recordConflict": "This field changed while you were saving. The value was not written; reload the secret and try again.",+ "secretConflict": "This secret changed while you were saving. Its fields are now refreshed; review them and save again. Your value was not written.",+ "replacePlaceholder": "Enter a replacement value",+ "revealField": "Field to reveal",+ "namesHelp": "Use lowercase letters, digits and underscores; start with a letter. Each field needs a unique name and a value.",+ "singleFile": "File upload supports one value. Switch to Text before adding fields.",+ "editHelp": "Changes save immediately. Adding, replacing or removing values expires grants; renaming the default field does not. Leave a value blank to keep it. Extra field names cannot be changed."+ },"protectedUnlock": {"checking": "Checking your protected vault…","unlocked": "Protected vault unlocked for this session",diff --git a/ui/src/i18n/zh.json b/ui/src/i18n/zh.jsonindex 0be7dc05e..8e6ccaade 100644--- a/ui/src/i18n/zh.json+++ b/ui/src/i18n/zh.json@@ -2520,6 +2520,15 @@"retry": "重试"},"errors": {+ "invalid_field_name": "字段名须为 1–64 个小写字母、数字或下划线,且以字母开头。",+ "field_exists": "此字段名已存在,请使用其他名称。",+ "field_not_found": "此字段已不存在。请刷新密钥并选择当前字段。",+ "too_many_fields": "每个密钥最多可包含 32 个字段(含默认字段)。",+ "fields_corrupt": "此密钥保存的字段数据已损坏。默认值仍可使用;为保留现有数据,字段修改已禁用。",+ "fields_not_supported": "签名密钥不支持命名字段或默认字段改名。",+ "record_mismatch": "保存期间字段记录发生变化,请刷新密钥后重试。",+ "secret_conflict": "此密钥已在其他位置修改。请检查刷新后的字段再试;你的修改尚未保存。",+ "secret_not_found": "此密钥已不存在。请刷新密钥库并选择其他密钥。","retry_not_available": "这条通知无法重试,可以发送消息继续。","retry_stale": "会话已经开始了后续任务,如需继续请发送消息。","retry_busy": "上一轮还在结束处理中,请稍后再试。",@@ -4974,18 +4983,45 @@"copy": "复制值","showInBrowser": "在浏览器中查看","errors": {+ "staleField": "此链接指向的字段已不存在。请打开密钥并选择当前字段。","contextFailed": "无法准备查看,请重试。","unavailable": "此保护档暂不支持查看。"}},"saved": "已更新 {{name}}",- "editSecret": "编辑信息",+ "editSecret": "编辑 Secret","rowActions": "更多操作","edit": {- "title": "编辑信息",- "subtitle": "普通信息不影响授权;Fetch 策略变化会重新审批",+ "title": "编辑 Secret",+ "subtitle": "值或 Fetch 策略变化后需要重新审批","lockedHint": "名称、类型、保护级别不可修改"},+ "fields": {+ "title": "字段",+ "name": "字段 {{index}} 名称",+ "namePlaceholder": "field_name",+ "value": "{{field}} 的值",+ "default": "默认",+ "defaultName": "默认字段名称",+ "newName": "新字段名称",+ "newValue": "新字段值",+ "add": "添加字段",+ "loginTemplate": "登录模板",+ "remove": "移除 {{field}}",+ "removeConfirm": "移除此字段及其值?已有授权将失效。",+ "rename": "改名",+ "save": "保存字段",+ "saveNamed": "保存 {{field}}",+ "saved": "字段已保存",+ "draftsDropped": "其他位置已移除字段,已丢弃这些草稿:{{fields}}。",+ "recordConflict": "保存期间字段记录发生变化。值未写入,请重新加载 Secret 后再试。",+ "secretConflict": "保存期间此密钥发生变化,字段已刷新。请检查后重新保存;你的值尚未写入。",+ "replacePlaceholder": "输入替换值",+ "revealField": "要显示的字段",+ "namesHelp": "使用小写字母、数字和下划线,以字母开头。每个字段的名称必须唯一且必须填写值。",+ "singleFile": "文件上传仅支持单值。添加字段前请先切换到文本模式。",+ "editHelp": "修改立即保存。添加、替换或移除值会使授权失效;默认字段改名不会。值留空则保留原值。额外字段不能改名。"+ },"protectedUnlock": {"checking": "正在检查你的保护层…","unlocked": "保护层已在本会话解锁",diff --git a/ui/src/lib/__fixtures__/p2_core_crypto.json b/ui/src/lib/__fixtures__/p2_core_crypto.jsonindex 2dc6f23f5..cfaa1682f 100644--- a/ui/src/lib/__fixtures__/p2_core_crypto.json+++ b/ui/src/lib/__fixtures__/p2_core_crypto.json@@ -75,6 +75,35 @@"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f","000000000000012c"]+ },+ {+ "purpose": "seal",+ "name": "GITHUB_LOGIN.username",+ "grant_id": "",+ "sign_scheme": "",+ "digest_hex": "",+ "approval_nonce_hex": "",+ "approval_expires_at_unix": null,+ "operation_hash_hex": "",+ "aad_hex": "617661756c743a626c696e642d626f783a6161643a7631000000047365616c000000154749544855425f4c4f47494e2e757365726e616d65000000116d616368696e652d61657367636d2d7631000000010100000000000000000000000000000000000000000000000000000000"+ },+ {+ "purpose": "agent-deliver",+ "name": "GITHUB_LOGIN.username",+ "grant_id": "gr_123",+ "sign_scheme": "",+ "digest_hex": "",+ "approval_nonce_hex": "0102030405060708090a0b0c0d0e0f10",+ "approval_expires_at_unix": 4102444800,+ "operation_hash_hex": "e4137f5335871dbb195eb2a7abb16ec57c7f18784c9f10792ae5a2e6e6d1582f",+ "aad_hex": "617661756c743a626c696e642d626f783a6161643a76310000000d6167656e742d64656c69766572000000154749544855425f4c4f47494e2e757365726e616d65000000116d616368696e652d61657367636d2d763100000001010000000667725f313233000000000000000000000000000000100102030405060708090a0b0c0d0e0f100000000800000000f486570000000020e4137f5335871dbb195eb2a7abb16ec57c7f18784c9f10792ae5a2e6e6d1582f",+ "ttl_secs": 300,+ "operation_hash_kind": "agent-deliver",+ "operation_hash_fields_hex": [+ "6167656e742d64656c69766572",+ "4749544855425f4c4f47494e2e757365726e616d65",+ "000000000000012c"+ ]}],"approval_nonce_hex": "0102030405060708090a0b0c0d0e0f10",diff --git a/ui/src/lib/useProtectedVault.ts b/ui/src/lib/useProtectedVault.tsindex 90751975a..dc740a5d8 100644--- a/ui/src/lib/useProtectedVault.ts+++ b/ui/src/lib/useProtectedVault.ts@@ -24,6 +24,7 @@ import { invalidateVaultSandboxPolicy } from './vaultSandboxPolicy';*/export type ProtectedUnlockMaterial = {name: string;+ field?: string;kind?: string | null;envelope: ProtectedRecordEnvelope;};diff --git a/ui/src/lib/vaultBrowserHandoff.test.tsx b/ui/src/lib/vaultBrowserHandoff.test.tsxindex d0039ed24..df50feac5 100644--- a/ui/src/lib/vaultBrowserHandoff.test.tsx+++ b/ui/src/lib/vaultBrowserHandoff.test.tsx@@ -1,7 +1,7 @@// @vitest-environment jsdomimport { createInstance } from 'i18next';-import { cleanup, render, screen, within } from '@testing-library/react';+import { cleanup, fireEvent, render, screen, within } from '@testing-library/react';import userEvent from '@testing-library/user-event';import type { ReactElement } from 'react';import { I18nextProvider, initReactI18next } from 'react-i18next';@@ -226,6 +226,16 @@ const cases: Array<{expect(await screen.findByRole('menuitem', { name: /^show value$/i })).toBeTruthy();},},+ {+ surface: 'protected field edit',+ desktop: () => <VaultSecretForm editSecret={protectedSecret} onCancel={vi.fn()} onCreated={vi.fn()} />,+ clicks: [openInBrowser],+ secrets: [protectedSecret],+ vaultStatus: 'locked',+ resumed: async () => {+ expect(within(await resumedDialog()).getByLabelText('Value for value')).toBeTruthy();+ },+ },];const ceremonies = [vault.setupPasskey, vault.unlockPasskey, vault.approveProtectedRelease, vault.signProtectedRequest, vault.revealProtectedValue];@@ -263,6 +273,29 @@ afterEach(() => {// on the request's Standard default, a reveal on a bare list, an agent's name dropped from Add),// strands the user in the browser; only a round trip through both ends catches that.describe('desktop shell protected-vault browser handoff', () => {+ // Field labels must survive the same round trip as the secret name; reopening just the+ // secret silently changes an extra-field reveal into a default-field reveal.+ it('resumes the selected extra field in the browser without revealing anything automatically', async () => {+ const user = userEvent.setup();+ api.getVaultRequests.mockResolvedValue({ requests: [] });+ api.listVaultSecrets.mockResolvedValue({+ secrets: [{ ...protectedSecret, default_field: 'password', fields: ['password', 'username'] }],+ });+ const open = vi.spyOn(window, 'open').mockReturnValue(null);+ Object.defineProperty(window, '__AVIBE_DESKTOP_SHELL__', { configurable: true, value: true });+ renderAt('/vaults', <VaultsPage />);+ await user.click(await screen.findByRole('button', { name: /^more actions$/i }));+ fireEvent.change(screen.getByRole('combobox', { name: 'Field to reveal' }), { target: { value: 'username' } });+ await user.click(screen.getByRole('menuitem', { name: /^show in browser$/i }));+ const target = new URL(String(open.mock.calls[0][0]));+ expect(target.searchParams.get('field')).toBe('username');+ cleanup();+ delete (window as { __AVIBE_DESKTOP_SHELL__?: true }).__AVIBE_DESKTOP_SHELL__;+ renderAt(`${target.pathname}${target.search}`, <VaultsPage />);+ expect((await screen.findByRole('combobox', { name: 'Field to reveal' }) as HTMLSelectElement).value).toBe('username');+ expect(vault.revealProtectedValue).not.toHaveBeenCalled();+ });+it.each(cases)('$surface resumes in the browser without starting a passkey step', async (c) => {const user = userEvent.setup();vault.status = c.vaultStatus ?? 'needs-setup';diff --git a/ui/src/lib/vaultBrowserHandoff.ts b/ui/src/lib/vaultBrowserHandoff.tsindex f1e3b20c3..d1f3ba606 100644--- a/ui/src/lib/vaultBrowserHandoff.ts+++ b/ui/src/lib/vaultBrowserHandoff.ts@@ -24,11 +24,13 @@ export type VaultBrowserStep =| { kind: 'request'; requestId: string; startProtected?: boolean }/** Add a new protected secret, fixed to `name` when an agent asked for it by name. */| { kind: 'add'; name?: string }+ /** Replace fields of an existing protected secret. */+ | { kind: 'edit'; secretName: string }/** Show a protected secret's value. */- | { kind: 'reveal'; secretName: string };+ | { kind: 'reveal'; secretName: string; field?: string };// `request_id` is also the deep link Avibe sends to IM (`vault_request_url`).-const STEP_PARAMS = ['request_id', 'protection', 'add', 'name', 'reveal'];+const STEP_PARAMS = ['request_id', 'protection', 'add', 'name', 'edit', 'reveal', 'field'];/** Opens Vaults in the user's browser on `step`. */export function openVaultsInBrowser(step: VaultBrowserStep): void {@@ -38,7 +40,9 @@ export function openVaultsInBrowser(step: VaultBrowserStep): void {? { request_id: step.requestId, ...(step.startProtected ? { protection: 'protected' } : {}) }: step.kind === 'add'? { add: 'protected', ...(step.name ? { name: step.name } : {}) }- : { reveal: step.secretName };+ : step.kind === 'edit'+ ? { edit: step.secretName }+ : { reveal: step.secretName, ...(step.field ? { field: step.field } : {}) };for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);openLinkInNewContext(url.toString());}@@ -48,8 +52,11 @@ export function readVaultBrowserStep(params: URLSearchParams): VaultBrowserStepconst requestId = params.get('request_id')?.trim();if (requestId) return { kind: 'request', requestId, startProtected: params.get('protection') === 'protected' };if (params.get('add') === 'protected') return { kind: 'add', name: params.get('name')?.trim() || undefined };+ const editName = params.get('edit')?.trim();+ if (editName) return { kind: 'edit', secretName: editName };const secretName = params.get('reveal')?.trim();- return secretName ? { kind: 'reveal', secretName } : null;+ const field = params.get('field')?.trim();+ return secretName ? { kind: 'reveal', secretName, ...(field ? { field } : {}) } : null;}/** `params` without a step, so a step resumed once doesn't resume again on reload. */diff --git a/ui/src/lib/vaultCrypto.test.ts b/ui/src/lib/vaultCrypto.test.tsindex fa4c81321..44caa6893 100644--- a/ui/src/lib/vaultCrypto.test.ts+++ b/ui/src/lib/vaultCrypto.test.ts@@ -32,6 +32,7 @@ import {packProtectedRecord,unpackProtectedRecord,signDigest,+ signProtectedDigest,SIGN_SCHEME_ECDSA_SECP256K1_DER,SIGN_SCHEME_ECDSA_SECP256K1_RECOVERABLE,SIGN_SCHEME_SCHNORR_SECP256K1_BIP340,@@ -214,6 +215,35 @@ describe('vaultCrypto signing vectors', () => {});describe('vaultCrypto blind boxes', () => {+ // Shared positive vectors permit field names for seal/deliver; pin the boundary so widening+ // that grammar cannot silently allow fields on signing keys or nested/invalid field names.+ it.each(['LOGIN.Password', 'LOGIN.1password', 'LOGIN.user.name', `LOGIN.${'x'.repeat(65)}`, '.password'])(+ 'rejects malformed field record %s', (name) => {+ expect(() => standardCreateBlindBoxContext(name)).toThrow('record name');+ },+ );++ it('rejects field records for signing even though they are valid seal records', async () => {+ const vector = p2.blind_box_aad_examples.cases.find((example) => example.purpose === 'agent-sign')!;+ await expect(protectedDekReleaseBlindBoxContext('KEY.password', {+ kind: 'agent-sign', grantId: vector.grant_id, signatureScheme: vector.sign_scheme as SignatureScheme,+ digest: vector.digest_hex, ttlSecs: vector.ttl_secs!, approval: approvalFromVector(vector),+ operationHash: vector.operation_hash_hex,+ })).rejects.toThrow('secret name');+ expect(() => blindBoxAad({+ purpose: 'agent-sign', name: 'KEY.password', grantId: vector.grant_id,+ signScheme: vector.sign_scheme as SignatureScheme, digest: bytesFromHex(vector.digest_hex),+ ttlSecs: vector.ttl_secs!, approvalNonce: bytesFromHex(vector.approval_nonce_hex),+ approvalExpiresAtUnix: vector.approval_expires_at_unix!, operationHash: bytesFromHex(vector.operation_hash_hex),+ })).toThrow('secret name');+ const vmk = newVmk();+ const key = importSigningKey('01'.padStart(64, '0'));+ const sealed = await sealProtected(key.privateKey, vmk, { name: 'KEY.password' });+ await expect(signProtectedDigest(+ sealed, vmk, { name: 'KEY.password' }, vector.digest_hex, vector.sign_scheme as SignatureScheme,+ )).rejects.toThrow('secret name');+ });+it('matches all shared avault blind-box AAD examples byte-for-byte', async () => {expect(p2.blind_box.aad_domain_utf8).toBe(BLIND_BOX_AAD_DOMAIN);expect(p2.blind_box_aad_examples.wrap_scheme).toBe(WRAP_SCHEME);diff --git a/ui/src/lib/vaultCrypto.ts b/ui/src/lib/vaultCrypto.tsindex b72036081..680d9a892 100644--- a/ui/src/lib/vaultCrypto.ts+++ b/ui/src/lib/vaultCrypto.ts@@ -17,6 +17,7 @@ const NONCE_BYTES = 12;const PASSKEY_PRF_SALT_BYTES = 32;const PASSKEY_HKDF_INFO = 'avault:protected-vmk:kek-passkey:v1';const SECRET_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;+const RECORD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*(\.[a-z][a-z0-9_]{0,63})?$/;const textEncoder = new TextEncoder();@@ -460,7 +461,7 @@ export function passkeyPrfSaltEntries(wrapMeta: string | WrapMeta): PasskeyPrfSa}function protectedRecordAad(context: ProtectedRecordContext): Uint8Array {- const name = utf8(validateSecretName(context.name));+ const name = utf8(validateRecordName(context.name));const scheme = utf8(context.scheme ?? WRAP_SCHEME);const out = new Uint8Array(name.length + scheme.length + 1);out.set(name, 0);@@ -492,7 +493,7 @@ async function requireValidPinnedPublicKey(publicKey: AvaultPublicKey): Promise<}function assertReleaseMatchesRecord(recordContext: ProtectedRecordContext, context: ProtectedDekReleaseBlindBoxContext): void {- if (validateSecretName(recordContext.name) !== validateSecretName(context.name)) {+ if (validateRecordName(recordContext.name) !== validateRecordName(context.name)) {throw new Error('protected DEK release context name does not match record name');}}@@ -708,6 +709,13 @@ function validateSecretName(name: string): string {return name;}+function validateRecordName(name: string): string {+ if (typeof name !== 'string' || !RECORD_NAME_PATTERN.test(name)) {+ throw new Error('vault secret name / record name must be NAME or NAME.field');+ }+ return name;+}+function validateNonEmpty(value: string, field: string): string {if (typeof value !== 'string' || value.trim() === '') {throw new Error(`${field} is required`);@@ -779,7 +787,7 @@ function normalizeBlindBoxContext(context: BlindBoxContext): BlindBoxContext {});return {purpose: 'agent-deliver',- name: validateSecretName(context.name),+ name: validateRecordName(context.name),grantId: validateNonEmpty(context.grantId, 'grant id'),ttlSecs: normalizeU64(context.ttlSecs, 'ttl seconds'),approvalNonce: approval.approvalNonce,@@ -812,7 +820,7 @@ function normalizeBlindBoxContext(context: BlindBoxContext): BlindBoxContext {export function standardCreateBlindBoxContext(name: string): StandardCreateBlindBoxContext {return {purpose: 'seal',- name: validateSecretName(name),+ name: validateRecordName(name),};}@@ -840,7 +848,7 @@ export async function protectedDekReleaseBlindBoxContext(name: string,operation: ProtectedDekReleaseOperation,): Promise<ProtectedDekReleaseBlindBoxContext> {- const normalizedName = validateSecretName(name);+ const normalizedName = operation.kind === 'agent-sign' ? validateSecretName(name) : validateRecordName(name);const approval = normalizeApproval(operation.approval);switch (operation.kind) {@@ -901,7 +909,7 @@ export async function blindBoxAgentDeliverOperationHash(): Promise<Uint8Array> {return blindBoxOperationHash(['agent-deliver',- validateSecretName(name),+ validateRecordName(name),u64Be(ttlSecs, 'ttl seconds'),]);}@@ -1014,6 +1022,7 @@ export async function signProtectedDigest(scheme: SignatureScheme,options: SignDigestOptions = {},): Promise<SignatureResult> {+ validateSecretName(context.name);const privateKey = await openProtected(sealedKey, vmk, context);try {return signDigest(privateKey, digest, scheme, options);diff --git a/ui/src/lib/vaultErrors.ts b/ui/src/lib/vaultErrors.tsnew file mode 100644index 000000000..fd6e861e8--- /dev/null+++ b/ui/src/lib/vaultErrors.ts@@ -0,0 +1,9 @@+import type { TFunction } from 'i18next';+import { errorMessage } from './errorMessage';++/** Use the same stable-code catalog as ApiContext's toast fallback. */+export function vaultErrorMessage(t: TFunction, error: unknown, fallback: string): string {+ const message = errorMessage(error) ?? fallback;+ const code = typeof error === 'object' && error !== null && 'code' in error ? error.code : null;+ return typeof code === 'string' && code ? t(`errors.${code}`, { defaultValue: message }) : message;+}diff --git a/ui/src/lib/vaultFields.test.ts b/ui/src/lib/vaultFields.test.tsnew file mode 100644index 000000000..828717bb8--- /dev/null+++ b/ui/src/lib/vaultFields.test.ts@@ -0,0 +1,14 @@+import { describe, expect, it } from 'vitest';+import { vaultHasNamedFieldShape } from './vaultFields';++describe('vaultHasNamedFieldShape', () => {+ it.each([+ [{ kind: 'static', default_field: 'value', fields: ['value'] }, false],+ [{ kind: 'static', default_field: 'password', fields: ['password'] }, true],+ [{ kind: 'static', default_field: 'password', fields: ['password', 'username'] }, true],+ [{ kind: 'static', default_field: 'value', fields: ['value'], fields_state: 'corrupt' }, true],+ [{ kind: 'keypair', default_field: 'value', fields: ['value'] }, false],+ ] as const)('classifies %o as %s', (secret, expected) => {+ expect(vaultHasNamedFieldShape(secret)).toBe(expected);+ });+});diff --git a/ui/src/lib/vaultFields.ts b/ui/src/lib/vaultFields.tsnew file mode 100644index 000000000..a22615148--- /dev/null+++ b/ui/src/lib/vaultFields.ts@@ -0,0 +1,34 @@+import type { VaultSecret } from '@/context/ApiContext';++export const VAULT_FIELD_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;+export const MAX_VAULT_FIELDS = 32;++export function vaultDefaultField(secret: Pick<VaultSecret, 'default_field'>): string {+ return secret.default_field && VAULT_FIELD_PATTERN.test(secret.default_field) ? secret.default_field : 'value';+}++export function vaultFieldNames(secret: Pick<VaultSecret, 'default_field' | 'fields'>): string[] {+ const defaultField = vaultDefaultField(secret);+ return [defaultField, ...(secret.fields ?? []).filter((field) => field !== defaultField)];+}++export function vaultFieldFingerprint(secret: Pick<VaultSecret, 'default_field' | 'fields' | 'fields_state' | 'updated_at'>): string {+ // Default labels are metadata-only and can change without an envelope version.+ return JSON.stringify([vaultDefaultField(secret), vaultFieldNames(secret), secret.fields_state ?? null, secret.updated_at]);+}++type VaultFieldShape = Pick<VaultSecret, 'default_field' | 'fields' | 'fields_state'> &+ Partial<Pick<VaultSecret, 'kind'>>;++export function vaultHasNamedFieldShape(secret: VaultFieldShape): boolean {+ if (secret.kind === 'keypair') return false;+ const fields = vaultFieldNames(secret);+ return secret.fields_state === 'corrupt'+ || secret.default_field !== 'value'+ || fields.length !== 1+ || fields[0] !== 'value';+}++export function vaultRecordName(name: string, field: string, defaultField: string): string {+ return field === defaultField ? name : `${name}.${field}`;+}diff --git a/vibe/api.py b/vibe/api.pyindex 846ab80b0..8f9c06a96 100644--- a/vibe/api.py+++ b/vibe/api.py@@ -2373,6 +2373,168 @@ def _vault_api_error_from_avault(exc: "AvaultError", *, prefix: str) -> VaultApireturn VaultApiError(f"{prefix}: {message}", code="avault_failed")+_VAULT_MAX_FIELDS = 32+++def _vault_validate_field_name(value: Any, *, field: str = "field") -> str:+ from storage import vault_service++ return vault_service.validate_field_name(value, field=field)+++def _vault_secret_record_names(meta: dict[str, Any]) -> list[str]:+ """Expand one value-free secret meta into its encrypted record names."""++ from storage import vault_service++ return [str(name) for name in vault_service.secret_record_names(meta)]+++def _vault_record_meta(+ conn: Any,+ ref: str,+ *,+ user_context: Any = None,+) -> dict[str, Any]:+ """Resolve a record ref through the storage public contract."""++ from storage import vault_service++ return dict(vault_service.get_secret_record_meta(conn, ref, user_context=user_context))+++def _vault_secret_management_meta(+ conn: Any,+ secret_name: str,+ *,+ user_context: Any = None,+) -> dict[str, Any]:+ """Authorize management before a field is sealed, then return masked meta."""++ from storage import vault_service++ vault_service.require_secret_management(conn, secret_name, user_context=user_context)+ return dict(vault_service.get_secret_meta(conn, secret_name, user_context=user_context))+++# Stable Web field errors: ApiContext/vaultErrorMessage resolve errors.<code>.+# The catalog contract test also probes all service exception mappings so adding+# a mapped code without declaring and translating it fails validation.+_VAULT_FIELD_ERROR_CODES = (+ "invalid_field_name",+ "field_exists",+ "field_not_found",+ "too_many_fields",+ "fields_corrupt",+ "fields_not_supported",+ "record_mismatch",+ "secret_conflict",+)+++def _vault_field_service_error(exc: Exception) -> VaultApiError:+ from storage import vault_service++ mappings: tuple[tuple[type[Exception], str, int], ...] = (+ (vault_service.InvalidFieldNameError, "invalid_field_name", 400),+ (vault_service.FieldExistsError, "field_exists", 409),+ (vault_service.FieldNotFoundError, "field_not_found", 404),+ (vault_service.TooManyFieldsError, "too_many_fields", 409),+ (vault_service.FieldsCorruptError, "fields_corrupt", 409),+ (vault_service.FieldsNotSupportedError, "fields_not_supported", 409),+ (vault_service.RecordMismatchError, "record_mismatch", 409),+ (vault_service.SecretConflictError, "secret_conflict", 409),+ )+ for error_type, code, status in mappings:+ if isinstance(exc, error_type):+ return VaultApiError(str(exc), code=code, status=status)+ if isinstance(exc, vault_service.InvalidRequestError):+ return VaultApiError(str(exc), code="invalid_request", status=409)+ if isinstance(exc, vault_service.SecretNotFoundError):+ return VaultApiError(str(exc), code="secret_not_found", status=404)+ if isinstance(exc, vault_service.VaultSecretAccessError):+ return _vault_secret_access_forbidden(exc)+ return VaultApiError(str(exc), code="vault_error")+++def _vault_create_field_specs(+ payload: dict[str, Any],+ *,+ secret_name: str,+ kind: str,+ default_field: str,+) -> list[dict[str, Any]]:+ from storage import vault_service++ if "fields" not in payload:+ return []+ raw_fields = payload.get("fields")+ if not isinstance(raw_fields, list):+ raise VaultApiError("fields must be an array", code="invalid_request", status=409)+ if kind == "keypair" and "fields" in payload:+ raise VaultApiError(+ "keypair secrets do not support fields",+ code="fields_not_supported",+ status=409,+ )+ if len(raw_fields) + 1 > _VAULT_MAX_FIELDS:+ raise VaultApiError(+ f"a vault secret can have at most {_VAULT_MAX_FIELDS} fields",+ code="too_many_fields",+ status=409,+ )+ names: set[str] = {default_field}+ specs: list[dict[str, Any]] = []+ envelope_key = "blind_box" if str(payload.get("protection") or "standard").strip().lower() == "standard" else "sealed"+ for index, item in enumerate(raw_fields):+ if not isinstance(item, dict):+ raise VaultApiError(+ f"fields[{index}] must be an object",+ code="invalid_request",+ status=409,+ )+ try:+ field_name = _vault_validate_field_name(item.get("name"), field=f"fields[{index}].name")+ except vault_service.InvalidFieldNameError as exc:+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc+ if field_name in names:+ raise VaultApiError(+ f"field {field_name!r} already exists",+ code="field_exists",+ status=409,+ )+ if "record" not in item:+ raise VaultApiError(+ f"fields[{index}].record is required",+ code="invalid_request",+ status=409,+ )+ record = item["record"]+ if not isinstance(record, str):+ raise VaultApiError(+ f"fields[{index}].record must be a string",+ code="record_mismatch",+ status=409,+ )+ expected_record = f"{secret_name}.{field_name}"+ if record != expected_record:+ raise VaultApiError(+ f"fields[{index}].record must be {expected_record!r}",+ code="record_mismatch",+ status=409,+ )+ envelope = item.get(envelope_key)+ if not isinstance(envelope, dict):+ raise VaultApiError(+ f"fields[{index}].{envelope_key} is required",+ code="invalid_envelope" if envelope_key == "sealed" else "blind_box_required",+ status=400,+ )+ names.add(field_name)+ specs.append({"name": field_name, "record": record, envelope_key: envelope})+ return specs++def _vault_engine():from storage.db import create_sqlite_enginefrom storage.importer import ensure_sqlite_state, resolve_primary_platform_from_config@@ -2830,7 +2992,11 @@ def create_vault_agent_bindings_batch(payload: dict) -> dict:ttl_seconds = int(duration["ttl_seconds"])expires_at = now + timedelta(seconds=ttl_seconds)expires_at_unix = int(expires_at.timestamp())- display = _operation_context_display(request_payload, grantable_members, grant_ttl_seconds=ttl_seconds)+ display_members: list[dict[str, Any]] = []+ for meta in grantable_members:+ for record_name in _vault_secret_record_names(meta):+ display_members.append({**meta, "name": record_name})+ display = _operation_context_display(request_payload, display_members, grant_ttl_seconds=ttl_seconds)agent = {"publicKey": {"public_key": str(agent_pubkey["public_key"]),@@ -2841,45 +3007,45 @@ def create_vault_agent_bindings_batch(payload: dict) -> dict:items: list[dict[str, Any]] = []issued_items: list[dict[str, Any]] = []for meta in protected_metas:- name = str(meta["name"])- approval_nonce = os.urandom(16)- context_request_id = f"vab_{uuid.uuid4().hex}"- release = {- "name": name,- "ttlSecs": ttl_seconds,- "approvalNonce": list(approval_nonce),- "approvalExpiresAtUnix": expires_at_unix,- "operationHash": _agent_deliver_operation_hash(name, ttl_seconds),- }- context = {- "v": 2,- "purpose": "agent-deliver",- "requestId": context_request_id,- "grantId": option["grant_id"],- "display": display,- "release": release,- "agent": agent,- "expiresAt": _isoformat_z(expires_at),- }- signed_context = _signed_operation_context(context, key)- approval = {- "nonce": _b64(approval_nonce),- "expires_at_unix": expires_at_unix,- }- items.append(- {+ for name in _vault_secret_record_names(meta):+ approval_nonce = os.urandom(16)+ context_request_id = f"vab_{uuid.uuid4().hex}"+ release = {"name": name,- "context": signed_context,- "approval": approval,+ "ttlSecs": ttl_seconds,+ "approvalNonce": list(approval_nonce),+ "approvalExpiresAtUnix": expires_at_unix,+ "operationHash": _agent_deliver_operation_hash(name, ttl_seconds),}- )- issued_items.append(- {- "name": name,- "request_id": context_request_id,- "approval": approval,+ context = {+ "v": 2,+ "purpose": "agent-deliver",+ "requestId": context_request_id,+ "grantId": option["grant_id"],+ "display": display,+ "release": release,+ "agent": agent,+ "expiresAt": _isoformat_z(expires_at),}- )+ signed_context = _signed_operation_context(context, key)+ approval = {+ "nonce": _b64(approval_nonce),+ "expires_at_unix": expires_at_unix,+ }+ items.append(+ {+ "name": name,+ "context": signed_context,+ "approval": approval,+ }+ )+ issued_items.append(+ {+ "name": name,+ "request_id": context_request_id,+ "approval": approval,+ }+ )with engine.begin() as conn:vault_service.record_request_agent_binding_approvals(conn,@@ -2919,11 +3085,19 @@ def create_vault_agent_binding(payload: dict) -> dict:raise VaultApiError("payload must be an object", code="invalid_payload")request_id = str(payload.get("request_id") or payload.get("requestId") or "").strip()grant_id = str(payload.get("grant_id") or payload.get("grantId") or "").strip()- name = str(payload.get("name") or "").strip()+ raw_name = payload.get("name")+ requested_name = raw_name if isinstance(raw_name, str) else ""+ if "." not in requested_name:+ requested_name = requested_name.strip()if not request_id or not grant_id:raise VaultApiError("request_id and grant_id are required", code="invalid_request", status=409)- if not vault_crypto.is_valid_secret_name(name):+ if not requested_name or not vault_crypto.is_valid_secret_name(requested_name.split(".", 1)[0]):raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")+ if "." in requested_name:+ try:+ _vault_validate_field_name(requested_name.split(".", 1)[1], field="field")+ except vault_service.InvalidFieldNameError as exc:+ raise _vault_field_service_error(exc) from excengine = _vault_engine()try:@@ -2931,7 +3105,8 @@ def create_vault_agent_binding(payload: dict) -> dict:option = _grant_option_from_request(conn, request_id)if grant_id != option["grant_id"]:raise vault_service.InvalidRequestError("grant id does not match the approval request")- if name not in set(option["member_names"]):+ base_name = requested_name.split(".", 1)[0]+ if base_name not in set(option["member_names"]):raise vault_service.InvalidRequestError("secret is not part of the approval request")grant_duration_value = _grant_duration_value_from_payload(payload)remember_duration = grant_duration_value is not None@@ -2939,14 +3114,20 @@ def create_vault_agent_binding(payload: dict) -> dict:grant_duration_value,default=option.get("default_grant_duration") or vault_service.get_vault_settings(conn)["last_grant_ttl"],)- meta = vault_service.get_secret_meta(conn, name)+ record_meta = _vault_record_meta(conn, requested_name)+ name = str(record_meta.get("record_name") or requested_name)+ meta = record_metaif meta.get("protection") != "protected":raise VaultApiError("agent binding is only valid for protected secrets", code="not_protected", status=409)key = _load_or_create_vault_daemon_binding_key(conn)if remember_duration:vault_service.save_vault_settings(conn, {"last_grant_ttl": duration["last_grant_ttl"]})except vault_service.SecretNotFoundError as exc:- raise VaultApiError(f"secret '{name}' not found", code="secret_not_found", status=404) from exc+ raise VaultApiError(+ f"secret '{requested_name}' not found",+ code="secret_not_found",+ status=404,+ ) from excexcept vault_service.VaultSecretAccessError as exc:raise _vault_secret_access_forbidden(exc) from excexcept vault_service.RequestNotFoundError as exc:@@ -2955,6 +3136,13 @@ def create_vault_agent_binding(payload: dict) -> dict:raise VaultApiError(str(exc), code="invalid_request", status=409) from excexcept vault_service.InvalidGrantError as exc:raise VaultApiError(str(exc), code="invalid_grant") from exc+ except (+ vault_service.InvalidFieldNameError,+ vault_service.FieldNotFoundError,+ vault_service.FieldsNotSupportedError,+ vault_service.FieldsCorruptError,+ ) as exc:+ raise _vault_field_service_error(exc) from excexcept vault_service.VaultServiceError as exc:raise VaultApiError(str(exc), code="vault_error") from exc@@ -3023,13 +3211,28 @@ def create_vault_agent_binding(payload: dict) -> dict:}-def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:+def create_vault_reveal_context(+ name: str,+ payload: dict | None = None,+ *,+ user_context: Any = None,+) -> dict:from storage import vault_crypto, vault_servicesecret_name = str(name or "").strip()if not vault_crypto.is_valid_secret_name(secret_name):raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")body = payload if isinstance(payload, dict) else {}+ _reject_plaintext_value_fields(body)+ field = body.get("field")+ if field is not None and not isinstance(field, str):+ raise VaultApiError("field must be a string", code="invalid_field_name", status=400)+ field_name = None+ if field is not None:+ try:+ field_name = _vault_validate_field_name(field, field="field")+ except vault_service.InvalidFieldNameError as exc:+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exctry:ttl_seconds = int(body.get("ttl_seconds") or body.get("ttlSecs") or 120)except (TypeError, ValueError) as exc:@@ -3040,12 +3243,20 @@ def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:expires_at = datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)try:with engine.begin() as conn:- meta = vault_service.get_secret_meta(conn, secret_name)+ record_ref = secret_name if field_name is None else f"{secret_name}.{field_name}"+ record_meta = _vault_record_meta(conn, record_ref, user_context=user_context)+ meta = dict(record_meta)if meta.get("protection") != "protected":raise VaultApiError("reveal context is only valid for protected secrets", code="not_protected", status=409)- envelope = vault_service.get_protected_record_envelope(conn, secret_name)+ record_name = str(record_meta.get("record_name") or record_ref)+ envelope = vault_service.get_protected_record_envelope(+ conn,+ record_name,+ user_context=user_context,+ )key = _load_or_create_vault_daemon_binding_key(conn)envelope_payload = _envelope_payload(envelope)+ display_meta = {**meta, "name": record_name}context = {"v": 2,"purpose": "reveal",@@ -3059,10 +3270,10 @@ def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:"source_selector": body.get("source") if isinstance(body.get("source"), dict) else {},}},- [meta],+ [display_meta],),"release": {- "name": secret_name,+ "name": record_name,"envelopeHash": _envelope_hash(envelope_payload),},"expiresAt": _isoformat_z(expires_at),@@ -3074,6 +3285,14 @@ def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:raise _vault_secret_access_forbidden(exc) from excexcept vault_service.KeypairNotValueDeliverableError as exc:raise VaultApiError(str(exc), code="keypair_not_value_deliverable", status=409) from exc+ except (+ vault_service.InvalidFieldNameError,+ vault_service.FieldNotFoundError,+ vault_service.FieldsNotSupportedError,+ ) as exc:+ raise _vault_field_service_error(exc) from exc+ except vault_service.VaultServiceError as exc:+ raise _vault_field_service_error(exc) from excreturn {"ok": True, "context": signed_context, "envelope": envelope_payload}@@ -3218,7 +3437,7 @@ def _reject_plaintext_value_fields(payload: object) -> None:_reject_plaintext_value_fields(item)-_VAULT_METADATA_ALLOWED_FIELDS = {"description", "tags", "policy"}+_VAULT_METADATA_ALLOWED_FIELDS = {"description", "tags", "policy", "default_field"}_VAULT_METADATA_SECRET_FIELDS = {"value","sealed",@@ -3268,7 +3487,12 @@ def _sealed_from_payload(payload: dict):return Sealed(ciphertext=ciphertext, nonce=nonce, wrap_meta=wrap_meta)-def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:+def create_vault_secret(+ payload: dict,+ *,+ origin: str | None = None,+ user_context: Any = None,+) -> dict:from storage import vault_crypto, vault_serviceif not isinstance(payload, dict):@@ -3294,9 +3518,28 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:if signer_kind is not None:signer_kind = str(signer_kind)provision_request_id = str(payload.get("provision_request_id") or "") or None+ if kind == "keypair" and ("fields" in payload or "default_field" in payload or "default_field" in (public_meta or {})):+ raise VaultApiError(+ "keypair secrets do not support fields or default_field",+ code="fields_not_supported",+ status=409,+ )+ if "default_field" in payload:+ try:+ default_field = _vault_validate_field_name(payload.get("default_field"), field="default_field")+ except vault_service.InvalidFieldNameError as exc:+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc+ else:+ default_field = "value"+ field_specs = _vault_create_field_specs(+ payload,+ secret_name=name,+ kind=kind,+ default_field=default_field,+ )atomic_protected_establishment = establishing_vmk and protection == "protected"try:- user_context = vault_service.require_secret_create_access()+ user_context = vault_service.require_secret_create_access(user_context=user_context)except vault_service.VaultSecretAccessError as exc:raise _vault_secret_access_forbidden(exc) from excengine = _vault_engine()@@ -3312,6 +3555,14 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:)except vault_service.InvalidSecretNameError as exc:raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name") from exc+ except (+ vault_service.InvalidFieldNameError,+ vault_service.FieldExistsError,+ vault_service.TooManyFieldsError,+ vault_service.FieldsNotSupportedError,+ vault_service.RecordMismatchError,+ ) as exc:+ raise _vault_field_service_error(exc) from excexcept vault_service.SecretNameCaseConflictError as exc:raise VaultApiError(f"secret name '{name}' conflicts with existing secret '{exc.existing_name}'",@@ -3349,12 +3600,26 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:sealed = _sealed_from_payload(payload.get("sealed") or payload.get("envelope") or payload)else:raise VaultApiError("invalid protection tier", code="invalid_protection")+ sealed_fields: list[dict[str, Any]] = []+ for spec in field_specs:+ field_name = str(spec["name"])+ record_name = str(spec["record"])+ if protection == "standard":+ try:+ field_sealed = avault_seal_blind_box(record_name, spec["blind_box"])+ except AvaultError as exc:+ raise VaultApiError(f"avault blind-box seal failed: {exc}", code="avault_failed") from exc+ else:+ field_sealed = _sealed_from_payload(spec["sealed"])+ sealed_fields.append({"name": field_name, "record": record_name, "sealed": field_sealed})try:with engine.begin() as conn:meta = vault_service.create_secret(conn,name=name,sealed=sealed,+ fields=sealed_fields,+ default_field=default_field if kind != "keypair" else None,tags=tags or None,protection=protection,kind=kind,@@ -3370,6 +3635,14 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:)except vault_service.InvalidSecretNameError as exc:raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name") from exc+ except (+ vault_service.InvalidFieldNameError,+ vault_service.FieldExistsError,+ vault_service.TooManyFieldsError,+ vault_service.FieldsNotSupportedError,+ vault_service.RecordMismatchError,+ ) as exc:+ raise _vault_field_service_error(exc) from excexcept vault_service.SecretNameCaseConflictError as exc:raise VaultApiError(f"secret name '{name}' conflicts with existing secret '{exc.existing_name}'",@@ -3405,7 +3678,7 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:return {"ok": True, "secret": meta}-def update_vault_secret(name: str, payload: dict) -> dict:+def update_vault_secret(name: str, payload: dict, *, user_context: Any = None) -> dict:from storage import vault_crypto, vault_serviceif not isinstance(payload, dict):@@ -3428,11 +3701,26 @@ def update_vault_secret(name: str, payload: dict) -> dict:release_scopes: list[dict[str, str]] = []try:with engine.begin() as conn:- meta = vault_service.update_secret_metadata(conn, secret_name, release_scopes=release_scopes, **kwargs)+ meta = vault_service.update_secret_metadata(+ conn,+ secret_name,+ release_scopes=release_scopes,+ user_context=user_context,+ **kwargs,+ )except vault_service.SecretNotFoundError as exc:raise VaultApiError(f"secret '{secret_name}' not found", code="secret_not_found", status=404) from excexcept vault_service.VaultSecretAccessError as exc:raise _vault_secret_access_forbidden(exc) from exc+ except (+ vault_service.InvalidFieldNameError,+ vault_service.FieldExistsError,+ vault_service.TooManyFieldsError,+ vault_service.FieldsNotSupportedError,+ vault_service.FieldsCorruptError,+ vault_service.SecretConflictError,+ ) as exc:+ raise _vault_field_service_error(exc) from excexcept vault_service.VaultServiceError as exc:raise VaultApiError(str(exc), code="invalid_metadata", status=409) from excrelease_vault_agent_scopes(release_scopes, reason="update_vault_secret")@@ -3440,6 +3728,181 @@ def update_vault_secret(name: str, payload: dict) -> dict:return {"ok": True, "secret": meta}+def update_vault_secret_field(+ name: str,+ field: str,+ payload: dict,+ *,+ user_context: Any = None,+) -> dict:+ from storage import vault_crypto, vault_service++ if not isinstance(payload, dict):+ raise VaultApiError("payload must be an object", code="invalid_payload")+ _reject_plaintext_value_fields(payload)+ secret_name = str(name or "").strip()+ if not vault_crypto.is_valid_secret_name(secret_name):+ raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")+ try:+ field_name = _vault_validate_field_name(field)+ except vault_service.InvalidFieldNameError as exc:+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc+ allowed = {"record", "blind_box", "sealed", "expected_updated_at"}+ extra = set(payload) - allowed+ if extra:+ raise VaultApiError(+ f"unsupported vault field payload fields: {', '.join(sorted(extra))}",+ code="invalid_request",+ status=409,+ )+ if "record" not in payload:+ raise VaultApiError("record is required", code="invalid_request", status=409)+ record = payload["record"]+ if not isinstance(record, str):+ raise VaultApiError("record must be a string", code="record_mismatch", status=409)+ expected_supplied = "expected_updated_at" in payload+ expected_updated_at = payload.get("expected_updated_at")+ if expected_supplied and expected_updated_at is not None and not isinstance(expected_updated_at, str):+ raise VaultApiError("expected_updated_at must be a string", code="invalid_request", status=409)++ engine = _vault_engine()+ try:+ with engine.connect() as conn:+ meta = _vault_secret_management_meta(+ conn,+ secret_name,+ user_context=user_context,+ )+ except vault_service.SecretNotFoundError as exc:+ raise VaultApiError(f"secret '{secret_name}' not found", code="secret_not_found", status=404) from exc+ except vault_service.VaultServiceError as exc:+ raise _vault_field_service_error(exc) from exc++ if meta.get("kind") == "keypair":+ raise VaultApiError(+ f"{secret_name} does not support fields",+ code="fields_not_supported",+ status=409,+ )+ default_field = str(meta.get("default_field") or "value")+ record_name = secret_name if field_name == default_field else f"{secret_name}.{field_name}"+ if record != record_name:+ raise VaultApiError(+ f"record does not match field {field_name!r} on {secret_name}",+ code="record_mismatch",+ status=409,+ )+ snapshot_updated_at = meta.get("updated_at")+ if expected_supplied and expected_updated_at != snapshot_updated_at:+ raise VaultApiError(+ f"secret '{secret_name}' changed while the field was being updated",+ code="secret_conflict",+ status=409,+ )++ protection = str(meta.get("protection") or "standard")+ if protection == "standard":+ if "sealed" in payload:+ raise VaultApiError("standard field updates require blind_box", code="invalid_request", status=409)+ blind_box = payload.get("blind_box")+ if not isinstance(blind_box, dict):+ raise VaultApiError("standard field update requires a browser blind_box", code="blind_box_required")+ try:+ sealed = avault_seal_blind_box(record_name, blind_box)+ except AvaultError as exc:+ raise VaultApiError(f"avault blind-box seal failed: {exc}", code="avault_failed") from exc+ elif protection == "protected":+ if "blind_box" in payload:+ raise VaultApiError("protected field updates require sealed", code="invalid_request", status=409)+ sealed = _sealed_from_payload(payload.get("sealed") or payload)+ else:+ raise VaultApiError("invalid protection tier", code="invalid_protection")++ release_scopes: list[dict[str, str]] = []+ try:+ with engine.begin() as conn:+ meta = vault_service.update_secret_field(+ conn,+ secret_name,+ field_name,+ sealed,+ record=record,+ expected_updated_at=snapshot_updated_at,+ release_scopes=release_scopes,+ user_context=user_context,+ )+ except vault_service.VaultServiceError as exc:+ raise _vault_field_service_error(exc) from exc+ release_vault_agent_scopes(release_scopes, reason="update_vault_secret_field")+ _publish_vaults_updated(scope="secret", secret_name=meta.get("name") or secret_name)+ return {"ok": True, "secret": meta}+++def delete_vault_secret_field(+ name: str,+ field: str,+ payload: dict | None = None,+ *,+ user_context: Any = None,+) -> dict:+ from storage import vault_crypto, vault_service++ body = {} if payload is None else payload+ if not isinstance(body, dict):+ raise VaultApiError("payload must be an object", code="invalid_payload")+ _reject_plaintext_value_fields(body)+ if set(body) - {"expected_updated_at"}:+ raise VaultApiError("unsupported field delete payload", code="invalid_request", status=409)+ expected_supplied = "expected_updated_at" in body+ expected_updated_at = body.get("expected_updated_at")+ if expected_supplied and not isinstance(expected_updated_at, str):+ raise VaultApiError("expected_updated_at must be a string", code="invalid_request", status=409)+ secret_name = str(name or "").strip()+ if not vault_crypto.is_valid_secret_name(secret_name):+ raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")+ try:+ field_name = _vault_validate_field_name(field)+ except vault_service.InvalidFieldNameError as exc:+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc+ engine = _vault_engine()+ try:+ with engine.connect() as conn:+ meta = _vault_secret_management_meta(+ conn,+ secret_name,+ user_context=user_context,+ )+ except vault_service.SecretNotFoundError as exc:+ raise VaultApiError(f"secret '{secret_name}' not found", code="secret_not_found", status=404) from exc+ except vault_service.VaultServiceError as exc:+ raise _vault_field_service_error(exc) from exc+ if meta.get("kind") == "keypair":+ raise VaultApiError(+ f"{secret_name} does not support fields",+ code="fields_not_supported",+ status=409,+ )+ snapshot_updated_at = meta.get("updated_at")+ if expected_supplied and expected_updated_at != snapshot_updated_at:+ raise _vault_field_service_error(vault_service.SecretConflictError(f"secret '{secret_name}' changed before field removal"))+ release_scopes: list[dict[str, str]] = []+ try:+ with engine.begin() as conn:+ updated = vault_service.remove_secret_field(+ conn,+ secret_name,+ field_name,+ expected_updated_at=expected_updated_at if expected_supplied else snapshot_updated_at,+ release_scopes=release_scopes,+ user_context=user_context,+ )+ except vault_service.VaultServiceError as exc:+ raise _vault_field_service_error(exc) from exc+ release_vault_agent_scopes(release_scopes, reason="delete_vault_secret_field")+ _publish_vaults_updated(scope="secret", secret_name=updated.get("name") or secret_name)+ return {"ok": True, "secret": updated}++def delete_vault_secret(name: str) -> dict:from storage import vault_service@@ -3474,7 +3937,12 @@ def get_vault_audit(*, secret_name: Optional[str] = None, limit: int = 100) -> ddef get_vault_requests(- *, status: Optional[str] = "pending", request_type: Optional[str] = None, limit: int = 100, session: Optional[str] = None+ *,+ status: Optional[str] = "pending",+ request_type: Optional[str] = None,+ limit: int = 100,+ session: Optional[str] = None,+ user_context: Any = None,) -> dict:from storage import vault_service@@ -3576,14 +4044,24 @@ def _vault_request_result(conn, request: dict) -> dict | None:return None-def get_vault_request(request_id: str, *, audience: str | None = None) -> dict:+def get_vault_request(+ request_id: str,+ *,+ audience: str | None = None,+ user_context: Any = None,+) -> dict:from storage import vault_servicerequest_audience = audience or vault_service.REQUEST_AUDIENCE_AGENTengine = _vault_engine()try:with engine.begin() as conn:- request = vault_service.get_request(conn, request_id, audience=request_audience)+ request = vault_service.get_request(+ conn,+ request_id,+ audience=request_audience,+ user_context=user_context,+ )result = _vault_request_result(conn, request)except vault_service.RequestNotFoundError as exc:raise VaultApiError(f"request '{request_id}' not found", code="request_not_found", status=404) from exc@@ -3646,24 +4124,29 @@ def _expires_at_from_ttl(payload: dict) -> str | None:return (datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)).isoformat()-def request_vault_access(payload: dict) -> dict:+def request_vault_access(payload: dict, *, user_context: Any = None) -> dict:from storage import vault_crypto, vault_serviceif not isinstance(payload, dict):raise VaultApiError("payload must be an object", code="invalid_payload")- name = str(payload.get("name") or "").strip()+ raw_name = payload.get("name")+ name = raw_name if isinstance(raw_name, str) else ""+ if "." not in name:+ name = name.strip()raw_selector = payload.get("source_selector")source_selector = dict(raw_selector) if isinstance(raw_selector, dict) else Noneif not name and source_selector is None:raise VaultApiError("name or source_selector is required", code="invalid_request", status=409)- if name and not vault_crypto.is_valid_secret_name(name):- raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")+ if name and not vault_crypto.is_valid_secret_name(name.split(".", 1)[0]):+ raise VaultApiError("invalid secret reference", code="invalid_name")purpose = str(payload.get("purpose") or "run")engine = _vault_engine()try:with engine.begin() as conn:if name:- vault_service.get_secret_meta(conn, name)+ if "." in name:+ vault_service.validate_field_name(name.split(".", 1)[1])+ vault_service.get_secret_record_meta(conn, name, user_context=user_context)request = vault_service.create_access_request(conn,name or None,@@ -3673,6 +4156,7 @@ def request_vault_access(payload: dict) -> dict:delivery=_vault_delivery_payload(payload),expires_at=_expires_at_from_ttl(payload),audience=vault_service.REQUEST_AUDIENCE_AGENT,+ user_context=user_context,)except vault_service.SecretNotFoundError as exc:missing_name = name or str(exc)@@ -3683,6 +4167,13 @@ def request_vault_access(payload: dict) -> dict:raise VaultApiError(str(exc), code="not_grantable", status=409) from excexcept vault_service.KeypairNotValueDeliverableError as exc:raise VaultApiError(str(exc), code="keypair_not_value_deliverable", status=409) from exc+ except (+ vault_service.FieldNotFoundError,+ vault_service.FieldsCorruptError,+ vault_service.InvalidFieldNameError,+ vault_service.FieldsNotSupportedError,+ ) as exc:+ raise _vault_field_service_error(exc) from excexcept vault_service.InvalidRequestError as exc:raise VaultApiError(str(exc), code="invalid_request", status=409) from excexcept vault_service.VaultServiceError as exc:@@ -3697,7 +4188,7 @@ def request_vault_access(payload: dict) -> dict:return {"ok": True, "request": request}-def request_vault_sign(payload: dict) -> dict:+def request_vault_sign(payload: dict, *, user_context: Any = None) -> dict:from storage import vault_crypto, vault_serviceif not isinstance(payload, dict):@@ -3712,7 +4203,7 @@ def request_vault_sign(payload: dict) -> dict:engine = _vault_engine()try:with engine.begin() as conn:- meta = vault_service.get_secret_meta(conn, name)+ meta = vault_service.get_secret_meta(conn, name, user_context=user_context)if meta.get("kind") != "keypair":raise VaultApiError(f"secret '{name}' is not a signing key", code="not_signing_key", status=409)if (meta.get("signer_kind") or "local") != "local":@@ -3735,6 +4226,7 @@ def request_vault_sign(payload: dict) -> dict:requester=_vault_ui_requester_payload(payload),delivery=_vault_delivery_payload(payload),expires_at=_expires_at_from_ttl(payload),+ user_context=user_context,)except vault_service.SecretNotFoundError as exc:raise VaultApiError(f"secret '{name}' not found", code="secret_not_found", status=404) from exc@@ -3935,6 +4427,7 @@ def _resident_agent_deks_from_payload(payload: dict, *, needs_agent_deks: bool)raise VaultApiError("resident agent grant requires sealed DEKs", code="invalid_grant")agent_deks: list[dict[str, Any]] = []allowed_keys = {"name", "dek_blindbox", "approval"}+ seen_names: set[str] = set()for item in deks:if not isinstance(item, dict):raise VaultApiError("resident agent grant DEKs must be objects", code="invalid_grant")@@ -3946,6 +4439,9 @@ def _resident_agent_deks_from_payload(payload: dict, *, needs_agent_deks: bool)approval = item.get("approval")if not isinstance(name, str) or not name or not isinstance(dek_blindbox, dict) or not isinstance(approval, dict):raise VaultApiError("resident agent grant DEKs require name, dek_blindbox, and approval", code="invalid_grant")+ if name in seen_names:+ raise VaultApiError("resident agent grant DEKs must contain unique record names", code="invalid_grant")+ seen_names.add(name)agent_deks.append({"name": name,@@ -4220,14 +4716,20 @@ def create_vault_grant(payload: dict) -> dict:if not grantable_members:raise VaultApiError("grant has no grantable static secrets", code="not_grantable", status=409)protected_member_names = {str(member["name"]) for member in grantable_members if member.get("protection") == "protected"}- needs_agent_deks = bool(protected_member_names)+ protected_record_names = {+ record_name+ for member in grantable_members+ if member.get("protection") == "protected"+ for record_name in _vault_secret_record_names(member)+ }+ needs_agent_deks = bool(protected_record_names)binding_grant_expires_at: str | None = Nonebinding_operation_ttl_seconds: int | None = Noneagent_deks = _resident_agent_deks_from_payload(payload, needs_agent_deks=needs_agent_deks)provided_names = {item["name"] for item in agent_deks}- if needs_agent_deks and provided_names != protected_member_names:- raise VaultApiError("resident agent DEKs must match the protected grant members", code="invalid_grant")+ if needs_agent_deks and provided_names != protected_record_names:+ raise VaultApiError("resident agent DEKs must match the protected grant records", code="invalid_grant")expected_member_names = {str(member["name"]) for member in grantable_members} if needs_agent_deks else Noneexpected_pubkey = payload.get("agent_pubkey") if isinstance(payload.get("agent_pubkey"), dict) else Noneif needs_agent_deks:@@ -4952,6 +5454,8 @@ def store_vault_pubkey_pin(payload: dict) -> dict:raise VaultApiError(f"secret '{name}' not found", code="secret_not_found", status=404) from excexcept vault_service.VaultSecretAccessError as exc:raise _vault_secret_access_forbidden(exc) from exc+ except vault_service.SecretConflictError as exc:+ raise _vault_field_service_error(exc) from exc_publish_vaults_updated(scope="secret", secret_name=meta.get("name") or name)return {"ok": True, "secret": meta}diff --git a/vibe/cli.py b/vibe/cli.pyindex 433323aed..034e212df 100644--- a/vibe/cli.py+++ b/vibe/cli.py@@ -8323,14 +8323,20 @@ def _is_env_name(name: str) -> bool:return all(c.isascii() and (c.isalnum() or c == "_") for c in name)-def _parse_env_specs_parts(specs) -> tuple[dict[str, str], list[str]]:+def _parse_env_specs_parts(+ specs,+ *,+ help_command: str = "vibe vault run --help",+) -> tuple[dict[str, str], list[str]]:"""Map ENV var name -> vault secret name from ``--env`` specs.Accepts ``NAME`` (inject as the same name), ``LOCAL=NAME`` (rename), andcomma-separated ``A,B`` within one flag."""+ from storage import vault_service+mapping: dict[str, str] = {}- env_by_secret: dict[str, str] = {}+ env_by_record: dict[str, str] = {}normalized: list[str] = []for spec in specs or []:for part in str(spec).split(","):@@ -8342,32 +8348,37 @@ def _parse_env_specs_parts(specs) -> tuple[dict[str, str], list[str]]:local, vault_name = local.strip(), vault_name.strip()else:local = vault_name = part+ if "." in vault_name:+ base, _, field = vault_name.partition(".")+ local = f"{base}_{field.upper()}"if not local or not vault_name:- raise TaskCliError(f"invalid --env spec: {part!r}", code="invalid_env_spec", help_command="vibe vault run --help")+ raise TaskCliError(f"invalid --env spec: {part!r}", code="invalid_env_spec", help_command=help_command)+ if "." in vault_name:+ vault_service.validate_field_name(vault_name.partition(".")[2])# The local (LHS) becomes an env var name / is interpolated into `export`# lines for eval — reject anything that isn't a plain identifier so it can't# break the shell or smuggle in extra commands.if not _is_env_name(local):- raise TaskCliError(f"invalid env var name: {local!r} (use [A-Za-z_][A-Za-z0-9_]*)", code="invalid_env_name", help_command="vibe vault run --help")+ raise TaskCliError(f"invalid env var name: {local!r} (use [A-Za-z_][A-Za-z0-9_]*)", code="invalid_env_name", help_command=help_command)existing = mapping.get(local)if existing is not None and existing != vault_name:raise TaskCliError(f"env var {local!r} maps to both {existing!r} and {vault_name!r}",code="conflicting_env_alias",- help_command="vibe vault run --help",+ help_command=help_command,)- existing_env = env_by_secret.get(vault_name)+ existing_env = env_by_record.get(vault_name)if existing_env is not None and existing_env != local:raise TaskCliError(f"secret '{vault_name}' was selected as both {existing_env!r} and {local!r}",code="conflicting_env_alias",hint="Use one --env alias for each selected secret.",- help_command="vibe vault run --help",+ help_command=help_command,)if existing == vault_name:continuemapping[local] = vault_name- env_by_secret[vault_name] = local+ env_by_record[vault_name] = localnormalized.append(vault_name if local == vault_name else f"{local}={vault_name}")return mapping, normalized@@ -8376,6 +8387,10 @@ def _parse_env_specs(specs) -> dict:return _parse_env_specs_parts(specs)[0]+def _record_secret_name(record: str) -> str:+ return str(record).split(".", 1)[0]++def _arg_list(args, name: str) -> list[str]:value = getattr(args, name, None)if value is None:@@ -8391,6 +8406,7 @@ def _add_vault_run_selection(*,vault_name: str,env_name: str,+ help_command: str = "vibe vault run --help",) -> None:if not vault_name or not env_name:raise TaskCliError("vault run selector produced an empty secret or env name", code="invalid_selector")@@ -8400,7 +8416,7 @@ def _add_vault_run_selection(raise TaskCliError(f"env var {env_name!r} is selected for both {existing_secret!r} and {vault_name!r}",code="conflicting_env_alias",- help_command="vibe vault run --help",+ help_command=help_command,)returnexisting_env = next((selected_env for selected_env, selected_secret in selections.items() if selected_secret == vault_name), None)@@ -8409,51 +8425,70 @@ def _add_vault_run_selection(f"secret '{vault_name}' was selected as both {existing_env!r} and {env_name!r}",code="conflicting_env_alias",hint="Use one --env alias for each selected secret.",- help_command="vibe vault run --help",+ help_command=help_command,)selections[env_name] = vault_name-def _resolve_vault_run_selectors(engine, args) -> tuple[dict[str, str], dict]:- """Expand --env/--tag/--skill to a fixed env-name -> vault-name plan."""+def _resolve_vault_run_selectors(+ engine,+ args,+ *,+ help_command: str = "vibe vault run --help",+) -> tuple[dict[str, str], dict]:+ """Expand --env/--tag/--skill to a canonical env-name -> record plan."""from storage import vault_serviceenv_specs = list(getattr(args, "env", None) or [])- explicit_mapping, normalized_env_specs = _parse_env_specs_parts(env_specs)+ normalized_env_specs: list[str] = []+ for spec in env_specs:+ for part in str(spec).split(","):+ # Conflicts belong to the canonical record plan: NAME and NAME.default+ # may name the same record under the same alias.+ _, normalized = _parse_env_specs_parts([part], help_command=help_command)+ normalized_env_specs.extend(normalized)tag_specs = _arg_list(args, "tag")skill_specs = _arg_list(args, "skill")selector_requested = bool(normalized_env_specs or tag_specs or skill_specs)selections: dict[str, str] = {}- for env_name, vault_name in explicit_mapping.items():- _add_vault_run_selection(selections, vault_name=vault_name, env_name=env_name)-- source_selector: dict = {"env": normalized_env_specs}- if tag_specs or skill_specs:+ selector = {+ "env": normalized_env_specs,+ "tags": tag_specs,+ "skills": skill_specs,+ }+ try:with engine.connect() as conn:- expanded = vault_service.expand_value_delivery_selector(conn, tags=tag_specs, skills=skill_specs)- source_selector["tags"] = list(expanded["source_selector"].get("tags") or [])- for item in expanded.get("secrets") or []:- _add_vault_run_selection(- selections,- vault_name=str(item.get("name") or ""),- env_name=str(item.get("env") or ""),+ expanded = vault_service.expand_value_delivery_selector(+ conn,+ source_selector=selector,)- else:- source_selector["tags"] = []+ except vault_service.InvalidRequestError as exc:+ message = str(exc)+ code = "conflicting_env_alias" if "conflict" in message or "maps to multiple" in message else "invalid_selector"+ raise TaskCliError(message, code=code, help_command=help_command) from exc++ for item in expanded.get("secrets") or []:+ _add_vault_run_selection(+ selections,+ vault_name=str(item.get("record") or ""),+ env_name=str(item.get("env") or ""),+ help_command=help_command,+ )+ source_selector = dict(expanded.get("source_selector") or {})if not selections and selector_requested:raise TaskCliError("vault run selector matched no value-deliverable secrets",code="no_matching_secrets",hint="Check the --env, --tag, or --skill selector, or ask the user to store/link the secret first.",- help_command="vibe vault run --help",+ help_command=help_command,)if not selections:raise TaskCliError("at least one --env NAME, --tag TAG, or --skill SKILL is required",code="missing_selector",- help_command="vibe vault run --help",+ help_command=help_command,)return selections, source_selector@@ -8523,10 +8558,14 @@ def _vault_lookup_next_steps(*, has_more: bool, has_filters: bool) -> list[str]:def _vault_capability_payload(secret: dict) -> dict:+ default_field = secret.get("default_field") or "value"return {"name": secret["name"],"kind": secret.get("kind"),"protection": secret.get("protection"),+ "default_field": default_field,+ "fields": secret.get("fields") or [default_field],+ **({"fields_state": "corrupt"} if secret.get("fields_state") == "corrupt" else {}),"tags": secret.get("tags") or [],"description": secret.get("description"),"policy": secret.get("policy") or {},@@ -8887,6 +8926,9 @@ def cmd_vault_edit(args):except vault_service.SecretNotFoundError:_print_task_error(TaskCliError(f"secret '{args.name}' not found", code="secret_not_found", help_command=help_command))return 1+ except vault_service.SecretConflictError as exc:+ _print_task_error(TaskCliError(str(exc), code="secret_conflict", help_command=help_command))+ return 1except vault_service.VaultServiceError as exc:_print_task_error(TaskCliError(str(exc), code="invalid_metadata", help_command=help_command))return 1@@ -8904,16 +8946,18 @@ def cmd_vault_access(args):help_command = "vibe vault access --help"name = getattr(args, "name", "")try:- if not vault_crypto.is_valid_secret_name(name):- raise TaskCliError(f"invalid secret name: {name!r} (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name", help_command=help_command)+ if not vault_crypto.is_valid_secret_name(_record_secret_name(name)):+ raise TaskCliError(f"invalid secret reference: {name!r}", code="invalid_name", help_command=help_command)engine = _open_vault_engine()with engine.begin() as conn:- vault_service.get_secret_meta(conn, name)+ record_meta = vault_service.get_secret_record_meta(conn, name)+ secret_name = str(record_meta["name"])+ record_name = str(record_meta["record_name"])request = vault_service.create_access_request(conn,- name,+ secret_name,requester=_vault_cli_requester(args),- delivery=_vault_cli_delivery(args, mode="access"),+ delivery={**_vault_cli_delivery(args, mode="access"), "record": record_name},)_publish_cli_vaults_updated(scope="request", request=request)_print_cli_payload(@@ -8926,6 +8970,18 @@ def cmd_vault_access(args):except vault_service.SecretNotFoundError:_print_task_error(TaskCliError(f"secret '{name}' not found", code="secret_not_found", help_command=help_command))return 1+ except vault_service.InvalidFieldNameError as exc:+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))+ return 1+ except vault_service.FieldsCorruptError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))+ return 1+ except vault_service.FieldNotFoundError as exc:+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))+ return 1+ except vault_service.FieldsNotSupportedError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))+ return 1except vault_service.NotGrantableError as exc:_print_task_error(TaskCliError(str(exc), code="not_grantable", help_command=help_command))return 1@@ -9000,41 +9056,43 @@ def _vault_cli_delivery_context(args, *, mode: str, **extra) -> tuple[dict, dictreturn requester, delivery, session_id-def _preflight_vault_names(engine, names: list[str], *, mixed_message: str, mixed_code: str = "mixed_protection_tiers") -> dict[str, dict]:+def _preflight_vault_run_batch(engine, mapping: dict[str, str]) -> dict[str, dict]:from storage import vault_servicemetas: dict[str, dict] = {}with engine.connect() as conn:- for name in dict.fromkeys(names):+ for record in dict.fromkeys(mapping.values()):+ name = _record_secret_name(record)+ if name in metas:+ continuemetas[name] = vault_service.get_secret_meta(conn, name)- tiers = {str(meta.get("protection") or "standard") for meta in metas.values()}- if len(tiers) > 1:- raise TaskCliError(mixed_message, code=mixed_code)+ if metas[name].get("kind") == "keypair":+ raise vault_service.KeypairNotValueDeliverableError(+ f"{record} is a signing key; use vibe vault sign instead of value delivery"+ )return metas-def _preflight_vault_run_batch(engine, mapping: dict[str, str]) -> dict[str, dict]:+def _preflight_vault_inject_batch(engine, names: list[str]) -> dict[str, dict]:from storage import vault_servicemetas: dict[str, dict] = {}with engine.connect() as conn:- for name in dict.fromkeys(mapping.values()):+ for record in dict.fromkeys(names):+ name = _record_secret_name(record)+ if name in metas:+ continuemetas[name] = vault_service.get_secret_meta(conn, name)if metas[name].get("kind") == "keypair":raise vault_service.KeypairNotValueDeliverableError(- f"{name} is a signing key; use vibe vault sign instead of value delivery"+ f"{record} is a signing key; use vibe vault sign instead of value delivery")+ tiers = {str(meta.get("protection") or "standard") for meta in metas.values()}+ if len(tiers) > 1:+ raise TaskCliError("mixing protected and standard secrets in one vault inject is not wired yet", code="mixed_protection_tiers")return metas-def _preflight_vault_inject_batch(engine, names: list[str]) -> dict[str, dict]:- return _preflight_vault_names(- engine,- names,- mixed_message="mixing protected and standard secrets in one vault inject is not wired yet",- )--class _AgentRunOutputBridge:"""Stream protected child stdio through temporary FIFOs owned by this CLI."""@@ -9400,6 +9458,17 @@ def _finish_one_shot_after_avault_error(_consume_after_possible_use(grants, reason=reason)+def _capture_vault_delivery_identities(engine, names: list[str], grants):+ from storage import vault_service++ try:+ with engine.connect() as conn:+ return vault_service.capture_delivery_identities(conn, names)+ except Exception:+ _release_one_shot_reservations(engine, grants)+ raise++def _resolve_vault_run_delivery(engine,mapping: dict[str, str],@@ -9416,14 +9485,14 @@ def _resolve_vault_run_delivery(metas = _preflight_vault_run_batch(engine, mapping)protected_names = [name- for name in dict.fromkeys(mapping.values())+ for name in dict.fromkeys(_record_secret_name(record) for record in mapping.values())if str(metas[name].get("protection") or "standard") == "protected"]standard_approval_error: TaskCliError | None = Noneapproval_request_to_publish: dict | None = Noneif metas and not protected_names:with engine.begin() as conn:- standard_names = list(dict.fromkeys(mapping.values()))+ standard_names = list(dict.fromkeys(_record_secret_name(record) for record in mapping.values()))approval_names = _always_ask_names(metas, standard_names)common_grant = vault_service.find_active_grant_for_secrets(conn,@@ -9434,8 +9503,13 @@ def _resolve_vault_run_delivery()if isinstance(common_grant, dict) and common_grant.get("one_shot") is True:return None, [common_grant], [- {"name": vault_name, "env": env_name, "envelope": vault_service.get_envelope(conn, vault_name)}- for env_name, vault_name in mapping.items()+ {+ "name": record,+ "env": env_name,+ "envelope": vault_service.get_envelope(conn, record),+ "tier": "standard",+ }+ for env_name, record in mapping.items()]if approval_names and _source_selector_tags(source_selector):req = vault_service.create_access_request(@@ -9466,7 +9540,7 @@ def _resolve_vault_run_delivery(needs_selector_set = _needs_protected_selector_set(protected_names, source_selector)selector_standard_names = [name- for name in dict.fromkeys(mapping.values())+ for name in dict.fromkeys(_record_secret_name(record) for record in mapping.values())if name not in protected_names and str(metas[name].get("protection") or "standard") == "standard"]selector_standard_approval_names = _always_ask_names(metas, selector_standard_names)@@ -9532,15 +9606,16 @@ def _resolve_vault_run_delivery()elif grant.get("one_shot") is True:one_shot_grants.append(grant)- for env_name, vault_name in mapping.items():+ for env_name, record in mapping.items():+ vault_name = _record_secret_name(record)if approval_error is not None:breakif vault_name in protected_names:secrets.append({- "name": vault_name,+ "name": record,"env": env_name,- "envelope": vault_service.get_protected_envelope(conn, vault_name),+ "envelope": vault_service.get_protected_envelope(conn, record),"tier": "protected",})@@ -9549,7 +9624,7 @@ def _resolve_vault_run_delivery(if resolved is None:resolved = vault_service.resolve_secret_access(conn,- vault_name,+ record,purpose="run",requester=requester,delivery=delivery,@@ -9570,9 +9645,12 @@ def _resolve_vault_run_delivery(current_grant = resolved.get("grant")if isinstance(current_grant, dict) and current_grant.get("one_shot") is True:one_shot_grants.append(current_grant)- item = {"name": vault_name, "env": env_name, "envelope": resolved["envelope"]}- if protected_names:- item["tier"] = "standard"+ item = {+ "name": record,+ "env": env_name,+ "envelope": vault_service.get_envelope(conn, record),+ "tier": "standard",+ }secrets.append(item)continueif resolved["status"] == "agent_delivery_ready":@@ -9624,41 +9702,103 @@ def _resolve_single_vault_delivery(raise TaskCliError(f"unsupported vault access status: {resolved['status']}", code="vault_access_error")-def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt: str, args=None):+def _resolve_vault_inject_delivery(+ engine,+ mapping: dict[str, str],+ *,+ path: str,+ fmt: str,+ args=None,+ source_selector: dict | None = None,+):from storage import vault_servicerequester, delivery, session_id = _vault_cli_delivery_context(args, mode="inject", path=path, format=fmt)+ names = list(mapping.values())+ secret_names = list(dict.fromkeys(_record_secret_name(record) for record in names))metas = _preflight_vault_inject_batch(engine, names)+ if source_selector:+ delivery["source_selector"] = source_selectortiers = {str(meta.get("protection") or "standard") for meta in metas.values()}if metas and tiers == {"protected"}:+ approval_request = Nonewith engine.begin() as conn:common_grant = vault_service.find_active_grant_for_secrets(conn,- names,+ secret_names,session_id=session_id,purpose="inject",reserve_one_shot=True,)if common_grant is not None:return common_grant, [common_grant] if common_grant.get("one_shot") is True else [], [- {"name": name, "key": name, "envelope": vault_service.get_protected_envelope(conn, name)}- for name in names+ {+ "name": record,+ "key": env_name,+ "envelope": vault_service.get_protected_envelope(conn, record),+ "tier": "protected",+ }+ for env_name, record in mapping.items()]+ if (+ _needs_protected_selector_set(secret_names, source_selector)+ and not _always_ask_names(metas, secret_names)+ ):+ request_delivery = dict(delivery)+ request_delivery["protected_secret_names"] = secret_names+ approval_request = vault_service.create_access_request(+ conn,+ None,+ source_selector=source_selector,+ requester=requester,+ delivery=request_delivery,+ purpose="inject",+ )+ if approval_request is not None:+ _publish_cli_vaults_updated(scope="request", request=approval_request)+ raise TaskCliError(+ "protected secrets need approval before vault inject delivery",+ code="approval_required",+ details={"request_id": approval_request.get("id"), "protected_secret_names": secret_names},+ )if metas and tiers == {"standard"}:+ approval_request = None+ approval_names = _always_ask_names(metas, secret_names)with engine.begin() as conn:standard_secrets = [- {"name": name, "key": name, "envelope": vault_service.get_envelope(conn, name)}- for name in names+ {+ "name": record,+ "key": env_name,+ "envelope": vault_service.get_envelope(conn, record),+ "tier": "standard",+ }+ for env_name, record in mapping.items()]common_grant = vault_service.find_active_grant_for_secrets(conn,- names,+ approval_names or secret_names,session_id=session_id,purpose="inject",reserve_one_shot=True,)if isinstance(common_grant, dict) and common_grant.get("one_shot") is True:return None, [common_grant], standard_secrets+ if approval_names and _source_selector_tags(source_selector):+ approval_request = vault_service.create_access_request(+ conn,+ None,+ source_selector=source_selector,+ requester=requester,+ delivery=delivery,+ purpose="inject",+ )+ if approval_request is not None:+ _publish_cli_vaults_updated(scope="request", request=approval_request)+ raise TaskCliError(+ "standard always_ask secrets need approval before vault inject delivery",+ code="approval_required",+ details={"request_id": approval_request.get("id"), "secret_names": approval_names},+ )secrets = []grant: dict | None = Noneone_shot_grants: list[dict] = []@@ -9668,12 +9808,13 @@ def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt:resolved_by_name: dict[str, dict] = {}try:with engine.begin() as conn:- for name in names:+ for env_name, record in mapping.items():+ name = _record_secret_name(record)resolved = resolved_by_name.get(name)if resolved is None:resolved = vault_service.resolve_secret_access(conn,- name,+ record,purpose="inject",requester=requester,delivery=delivery,@@ -9694,7 +9835,15 @@ def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt:current_grant = resolved.get("grant")if isinstance(current_grant, dict) and current_grant.get("one_shot") is True:one_shot_grants.append(current_grant)- secrets.append({"name": name, "key": name, "envelope": resolved["envelope"], "protected": False})+ secrets.append(+ {+ "name": record,+ "key": env_name,+ "envelope": vault_service.get_envelope(conn, record),+ "tier": "standard",+ "protected": False,+ }+ )continueif resolved["status"] == "agent_delivery_ready":current_grant = resolved["grant"]@@ -9709,7 +9858,15 @@ def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt:breakif current_grant.get("one_shot") is True:one_shot_grants.append(current_grant)- secrets.append({"name": name, "key": name, "envelope": resolved["envelope"], "protected": True})+ secrets.append(+ {+ "name": record,+ "key": env_name,+ "envelope": vault_service.get_protected_envelope(conn, record),+ "tier": "protected",+ "protected": True,+ }+ )continueraise TaskCliError(f"unsupported vault access status: {resolved['status']}", code="vault_access_error")except Exception as exc:@@ -9797,6 +9954,18 @@ def cmd_vault_run(args):))return 1+ except vault_service.FieldsCorruptError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))+ return 1+ except vault_service.FieldNotFoundError as exc:+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))+ return 1+ except vault_service.InvalidFieldNameError as exc:+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))+ return 1+ except vault_service.FieldsNotSupportedError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))+ return 1except vault_service.UnsupportedProtectionError as exc:_print_task_error(TaskCliError(str(exc), code="protected_tier_unavailable", help_command=help_command))return 1@@ -9814,6 +9983,7 @@ def cmd_vault_run(args):handoff_started = Falsetry:+ audit_identities = _capture_vault_delivery_identities(engine, [str(secret["name"]) for secret in secrets], one_shot_grants)if grant is not None:secret_env_names = {str(secret["env"]) for secret in secrets if secret.get("env")}with _AgentRunOutputBridge(@@ -9855,7 +10025,7 @@ def cmd_vault_run(args):)requester, delivery, _session_id = _vault_cli_delivery_context(args, mode="run", command=command_argv)protected_names = [- str(secret["name"])+ _record_secret_name(secret["name"])for secret in secretsif secret.get("tier") == "protected" and secret.get("name")]@@ -9889,7 +10059,7 @@ def cmd_vault_run(args):try:with engine.begin() as conn:vault_service.record_deliveries(- conn, sorted(set(mapping.values())), requester={"source": "cli", "pid": os.getpid()}, mode="run"+ conn, audit_identities, requester={"source": "cli", "pid": os.getpid()}, mode="run")except Exception:pass@@ -10056,6 +10226,19 @@ def _wait_for_vault_delivery_approval(args, exc: TaskCliError, *, timeout: floatraise terminal_error+def _vault_provision_success_usage(engine, name: str) -> str:+ from storage import vault_service++ try:+ with engine.connect() as conn:+ metadata = vault_service.get_secret_meta(conn, name)+ except vault_service.SecretNotFoundError:+ return " — check `vibe vault list` for its current availability."+ if vault_service.has_named_field_shape(metadata):+ return vault_service.provision_field_hint(metadata)+ return f" — use it via: vibe vault run --env {name} -- <command>"++def cmd_vault_request(args):from storage import vault_crypto, vault_service@@ -10085,7 +10268,7 @@ def cmd_vault_request(args):secret_name=name,status="fulfilled",request=req,- message=f"'{name}' is already in the vault — use it via: vibe vault run --env {name} -- <command>",+ message=f"'{name}' is already in the vault{_vault_provision_success_usage(engine, name)}",)return 0wait_seconds = getattr(args, "wait", None)@@ -10138,7 +10321,7 @@ def cmd_vault_request(args):secret_name=name,status="fulfilled",request=waited,- message=f"'{name}' is now available — use it via: vibe vault run --env {name} -- <command>",+ message=f"'{name}' is now available{_vault_provision_success_usage(engine, name)}",)return 0_print_task_error(@@ -10511,8 +10694,10 @@ def _build_vault_fetch_request(# and after an approval wait so a mid-wait metadata edit cannot leave a stale allowlist or auth# injection policy in the egress frame.with engine.connect() as conn:- policy = vault_service.get_secret_policy(conn, name)- meta = vault_service.get_secret_meta(conn, name)+ record_meta = vault_service.get_secret_record_meta(conn, name)+ secret_name = str(record_meta["name"])+ policy = vault_service.get_secret_policy(conn, secret_name)+ meta = record_metaif meta.get("kind") == "keypair":raise vault_service.KeypairNotValueDeliverableError(f"{name} is a signing key; use vault_sign instead of value delivery"@@ -10605,6 +10790,9 @@ def cmd_vault_fetch(args):)engine = _open_vault_engine()+ with engine.connect() as conn:+ record_meta = vault_service.get_secret_record_meta(conn, name)+ name = str(record_meta["record_name"])request = _build_vault_fetch_request(engine,name=name,@@ -10652,6 +10840,7 @@ def cmd_vault_fetch(args):body=body,help_command=help_command,)+ audit_identity = _capture_vault_delivery_identities(engine, [name], [one_shot_grant] if one_shot_grant else [])[0]handoff_started = Trueif grant is not None:result = api.avault_agent_deliver_fetch(@@ -10671,7 +10860,7 @@ def cmd_vault_fetch(args):with engine.begin() as conn:vault_service.record_proxy_use(conn,- name,+ audit_identity,requester={"source": "cli", "pid": os.getpid()},delivery={"host": host, "method": method, "status": status},)@@ -10686,6 +10875,18 @@ def cmd_vault_fetch(args):except vault_service.KeypairNotValueDeliverableError as exc:_print_task_error(TaskCliError(str(exc), code="keypair_not_value_deliverable", help_command=help_command))return 1+ except vault_service.InvalidFieldNameError as exc:+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))+ return 1+ except vault_service.FieldsCorruptError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))+ return 1+ except vault_service.FieldNotFoundError as exc:+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))+ return 1+ except vault_service.FieldsNotSupportedError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))+ return 1except vault_service.UnsupportedProtectionError as exc:_print_task_error(TaskCliError(str(exc), code="protected_tier_unavailable", help_command=help_command))return 1@@ -10774,12 +10975,20 @@ def cmd_vault_inject(args):grant = Noneone_shot_grants: list[dict] = []keys: list[str] = []+ secrets: list[dict] = []handoff_started = Falsetry:keys = [k.strip() for k in (getattr(args, "keys", None) or "").split(",") if k.strip()]keys = list(dict.fromkeys(keys)) # dedupe, preserve order: A,A is one entry + one audit- if not keys:- raise TaskCliError("--keys A,B is required", code="missing_keys", help_command=help_command)+ env_specs = list(getattr(args, "env", None) or [])+ tag_specs = _arg_list(args, "tag")+ skill_specs = _arg_list(args, "skill")+ if not keys and not env_specs and not tag_specs and not skill_specs:+ raise TaskCliError(+ "at least one --keys, --env NAME, --tag TAG, or --skill SKILL is required",+ code="missing_keys",+ help_command=help_command,+ )out = getattr(args, "out", None)if not out:raise TaskCliError("--out FILE is required", code="missing_out", help_command=help_command)@@ -10796,7 +11005,22 @@ def cmd_vault_inject(args):engine = _open_vault_engine()resolved_out = _resolve_cli_output_path(str(out))_preflight_cli_output_path(resolved_out, help_command=help_command)- grant, one_shot_grants, secrets = _resolve_vault_inject_delivery(engine, keys, path=resolved_out, fmt=fmt, args=args)+ selector_args = argparse.Namespace(**vars(args))+ selector_args.env = [*env_specs, *keys]+ mapping, source_selector = _resolve_vault_run_selectors(+ engine,+ selector_args,+ help_command=help_command,+ )+ grant, one_shot_grants, secrets = _resolve_vault_inject_delivery(+ engine,+ mapping,+ path=resolved_out,+ fmt=fmt,+ args=args,+ source_selector=source_selector,+ )+ audit_identities = _capture_vault_delivery_identities(engine, [str(item["name"]) for item in secrets], one_shot_grants)# avault writes the 0600 file atomically; if the path is unwritable it raises and no# delivery is recorded.handoff_started = True@@ -10814,10 +11038,21 @@ def cmd_vault_inject(args):# (callers would retry though the secrets are already written), so record best-effort.try:with engine.begin() as conn:- vault_service.record_deliveries(conn, keys, requester={"source": "cli", "pid": os.getpid()}, mode=f"inject:{fmt}")+ vault_service.record_deliveries(+ conn,+ audit_identities,+ requester={"source": "cli", "pid": os.getpid()},+ mode=f"inject:{fmt}",+ )except Exception:pass- _print_cli_payload("vault_inject", written=True, path=resolved_out, format=fmt, keys=keys)+ _print_cli_payload(+ "vault_inject",+ written=True,+ path=resolved_out,+ format=fmt,+ keys=[str(item["key"]) for item in secrets],+ )return 0except vault_service.SecretNotFoundError as exc:_print_task_error(TaskCliError(f"secret '{exc}' not found", code="secret_not_found", help_command=help_command))@@ -10825,6 +11060,18 @@ def cmd_vault_inject(args):except vault_service.KeypairNotValueDeliverableError as exc:_print_task_error(TaskCliError(str(exc), code="keypair_not_value_deliverable", help_command=help_command))return 1+ except vault_service.InvalidFieldNameError as exc:+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))+ return 1+ except vault_service.FieldsCorruptError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))+ return 1+ except vault_service.FieldNotFoundError as exc:+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))+ return 1+ except vault_service.FieldsNotSupportedError as exc:+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))+ return 1except vault_service.UnsupportedProtectionError as exc:_print_task_error(TaskCliError(str(exc), code="protected_tier_unavailable", help_command=help_command))return 1@@ -10844,10 +11091,14 @@ def cmd_vault_inject(args):path=resolved_out,format=fmt,)+ delivery["source_selector"] = source_selector+ delivery["protected_secret_names"] = list(+ dict.fromkeys(_record_secret_name(item["name"]) for item in secrets)+ )_expire_agent_grant_after_missing(engine,grant["id"],- keys,+ [str(item["name"]) for item in secrets] or keys,requester=requester,delivery=delivery,purpose="inject",@@ -17890,7 +18141,7 @@ def build_parser():"--env",action="append",metavar="NAME[,N2]|LOCAL=NAME",- help="Inject secret NAME as env var NAME (LOCAL=NAME to rename; comma-separates several). Repeatable.",+ help="Inject secret NAME or NAME.field as env var NAME (NAME.field defaults to NAME_FIELD; LOCAL=NAME[.field] to rename; comma-separates several). Repeatable.",)vault_run_parser.add_argument("--tag", action="append", metavar="TAG", help="Inject all value-deliverable secrets with this tag. Repeatable.")vault_run_parser.add_argument("--skill", action="append", metavar="SKILL", help="Sugar for --tag skill:SKILL. Repeatable.")@@ -17911,7 +18162,7 @@ def build_parser():formatter_class=argparse.RawDescriptionHelpFormatter,error_help_command="vibe vault fetch --help",)- vault_fetch_parser.add_argument("--auth", required=True, metavar="NAME", help="Secret to attach as the request credential")+ vault_fetch_parser.add_argument("--auth", required=True, metavar="NAME[.field]", help="Secret record to attach as the request credential")vault_fetch_parser.add_argument("--url", required=True, help="Target URL (host must be in the secret's allowed_hosts)")vault_fetch_parser.add_argument("--method", default="GET", help="HTTP method (default GET)")vault_fetch_parser.add_argument("--header", action="append", metavar="'Name: value'", help="Extra request header (repeatable)")@@ -17932,7 +18183,7 @@ def build_parser():formatter_class=argparse.RawDescriptionHelpFormatter,error_help_command="vibe vault access --help",)- vault_access_parser.add_argument("name", help="Static secret name to request")+ vault_access_parser.add_argument("name", help="Static secret or record reference NAME[.field] to request")vault_access_parser.add_argument("--session-id", help="Agent Session ID. Defaults from AVIBE_SESSION_ID inside an Agent shell.")vault_access_parser.add_argument("--skill", help="Skill requesting the secret")vault_access_parser.add_argument("--command", dest="operation_command", help="Command or operation shown to the user")@@ -18014,7 +18265,19 @@ def build_parser():formatter_class=argparse.RawDescriptionHelpFormatter,error_help_command="vibe vault inject --help",)- vault_inject_parser.add_argument("--keys", required=True, metavar="A,B", help="Comma-separated secret names")+ vault_inject_parser.add_argument(+ "--keys",+ metavar="NAME[.field],...",+ help="Compatibility alias for comma-separated secret record references",+ )+ vault_inject_parser.add_argument(+ "--env",+ action="append",+ metavar="NAME[,N2]|LOCAL=NAME",+ help="Inject secret NAME or NAME.field using the same selectors as vault run",+ )+ vault_inject_parser.add_argument("--tag", action="append", metavar="TAG", help="Inject all value-deliverable records from secrets with this tag. Repeatable.")+ vault_inject_parser.add_argument("--skill", action="append", metavar="SKILL", help="Sugar for --tag skill:SKILL. Repeatable.")vault_inject_parser.add_argument("--out", required=True, metavar="FILE", help="Output file (written 0600)")vault_inject_parser.add_argument("--format", default="dotenv", choices=["dotenv", "json", "yaml", "toml"], help="Output format (default dotenv)")_add_json_noop(vault_inject_parser)diff --git a/vibe/ui_server.py b/vibe/ui_server.pyindex b93cb0de6..6a3d81ebb 100644--- a/vibe/ui_server.py+++ b/vibe/ui_server.py@@ -5859,7 +5859,13 @@ def vault_secrets_post():from vibe import apitry:- return jsonify(api.create_vault_secret(request.json or {}, origin=_vault_sandbox_webauthn_origin()))+ return jsonify(+ api.create_vault_secret(+ request.json or {},+ origin=_vault_sandbox_webauthn_origin(),+ user_context=getattr(g, "authorization_context", None),+ )+ )except ValueError as exc:return _vault_error_response(exc)@@ -5869,11 +5875,68 @@ def vault_secret_patch(name):from vibe import apitry:- return jsonify(api.update_vault_secret(name, request.json or {}))+ return jsonify(+ api.update_vault_secret(+ name,+ request.json or {},+ user_context=getattr(g, "authorization_context", None),+ )+ )except ValueError as exc:return _vault_error_response(exc)[email protected]("/api/vault/secrets/{name}/fields/{field}", include_in_schema=False)+async def vault_secret_field_put(+ name: str,+ field: str,+ starlette_request: FastAPIRequest,+):+ async def handler():+ from vibe import api++ try:+ payload = request.json if isinstance(request.json, dict) else {}+ return jsonify(+ await asyncio.to_thread(+ api.update_vault_secret_field,+ name,+ field,+ payload,+ user_context=getattr(g, "authorization_context", None),+ )+ )+ except ValueError as exc:+ return _vault_error_response(exc)++ return await _dispatch_native_ui_request(starlette_request, handler)++[email protected]("/api/vault/secrets/{name}/fields/{field}", include_in_schema=False)+async def vault_secret_field_delete(+ name: str,+ field: str,+ starlette_request: FastAPIRequest,+):+ async def handler():+ from vibe import api++ try:+ return jsonify(+ await asyncio.to_thread(+ api.delete_vault_secret_field,+ name,+ field,+ request.json,+ user_context=getattr(g, "authorization_context", None),+ )+ )+ except ValueError as exc:+ return _vault_error_response(exc)++ return await _dispatch_native_ui_request(starlette_request, handler)++@app.route("/api/vault/secrets/<name>", methods=["DELETE"])def vault_secret_delete(name):from vibe import api@@ -5889,7 +5952,13 @@ def vault_secret_reveal_context_post(name):from vibe import apitry:- return jsonify(api.create_vault_reveal_context(name, request.json or {}))+ return jsonify(+ api.create_vault_reveal_context(+ name,+ request.json or {},+ user_context=getattr(g, "authorization_context", None),+ )+ )except ValueError as exc:return _vault_error_response(exc)@@ -5906,7 +5975,15 @@ def vault_requests_get():limit = int(request.args.get("limit") or 100)except ValueError:limit = 100- return jsonify(api.get_vault_requests(status=status, request_type=req_type, limit=limit, session=session))+ return jsonify(+ api.get_vault_requests(+ status=status,+ request_type=req_type,+ limit=limit,+ session=session,+ user_context=getattr(g, "authorization_context", None),+ )+ )@app.route("/api/vault/requests/<request_id>", methods=["GET"])@@ -5915,7 +5992,13 @@ def vault_request_get(request_id):from storage import vault_servicetry:- return jsonify(api.get_vault_request(request_id, audience=vault_service.REQUEST_AUDIENCE_UI))+ return jsonify(+ api.get_vault_request(+ request_id,+ audience=vault_service.REQUEST_AUDIENCE_UI,+ user_context=getattr(g, "authorization_context", None),+ )+ )except ValueError as exc:return _vault_error_response(exc)@@ -5945,7 +6028,12 @@ def vault_access_request_post():from vibe import apitry:- return jsonify(api.request_vault_access(request.json or {}))+ return jsonify(+ api.request_vault_access(+ request.json or {},+ user_context=getattr(g, "authorization_context", None),+ )+ )except ValueError as exc:return _vault_error_response(exc)@@ -5955,7 +6043,12 @@ def vault_sign_request_post():from vibe import apitry:- return jsonify(api.request_vault_sign(request.json or {}))+ return jsonify(+ api.request_vault_sign(+ request.json or {},+ user_context=getattr(g, "authorization_context", None),+ )+ )except ValueError as exc:return _vault_error_response(exc)