feat(vault): M4 write paths — vault add + vault edit

Completes the M4 write verbs (`remove`/`generate` shipped in 61a56fb). `add`
and `edit` are the inverse of the read path: caller-supplied plaintext fields
are encrypted inside the agent — the unwrapped user key never crosses the UDS
— and POST/PUT to the server. Login and secure-note types are supported.

- vault-core: `Cipher::from_plain` — the encryption inverse of `decrypt`;
  assembles a /sync-shaped Cipher from a PlainCipher. 3 round-trip tests.
- vault-api: `create_cipher` (POST /api/ciphers → new id) and `update_cipher`
  (PUT /api/ciphers/{id}). camelCase request body (CipherRequest) reusing
  vault-core's PascalCase Login nested, with a `secureNote` marker on type 2.
  Shared `bearer_headers` helper. Wiremock tests assert method/path/Bearer, an
  EncString-shaped name, and the type-2 secureNote marker.
- vault-ipc: `Request::Add` / `Request::Edit` (plaintext optional fields,
  secrets as `Vec<u8>`) and `Response::Saved { id, name }`.
- vault-agent: `add_cipher` / `edit_cipher`, with folder name→id resolution.
  `edit` re-encrypts only changed fields onto a clone of the original encrypted
  cipher (`apply_cipher_edits`), so secondary URIs, custom fields, and org
  membership it doesn't model survive verbatim — `--uri` replaces the primary
  and keeps the rest. Two unit tests prove a secondary URI survives an edit.
  Secrets wiped via PlainCipher/Zeroizing.
- vault-cli: `vault add <name> [--type login|note] [--username] [--uri]
  [--folder] [--notes] [--generate[=LEN]] [--json]` (password from stdin or
  generated; no --password flag, so secrets never enter argv) and
  `vault edit <selector> [field flags] [--password|--generate] [--json]`.

Remaining M4: `--json` on unlock/lock/sync/stop-agent, and a real re-pull
`vault sync`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: UnbreakableMJ

CHANGELOG.md

@@ -8,6 +8,35 @@ range may break in any release.
 
 ## [Unreleased]
 
+### Added
+
+- **M4 (slice 3) — `vault add` + `vault edit`.** The two remaining write verbs,
+  the inverse of the read path: caller-supplied plaintext fields are encrypted
+  **inside the agent** (the user key never leaves it) and `POST`/`PUT` to the
+  server. Login (`--type login`) and secure note (`--type note`) are supported.
+  - `vault add <name> [--type login|note] [--username U] [--uri URL]
+    [--folder F] [--notes N] [--generate[=LEN]] [--json]`. The password is read
+    from stdin or generated locally with `--generate` (printed back so the user
+    has it); no `--password` flag, so secrets never enter argv / shell history.
+  - `vault edit <selector> [--name|--username|--uri|--folder|--notes ...]
+    [--password (stdin)] [--generate[=LEN]] [--json]`. Only the flags you pass
+    change; `edit` re-encrypts just those fields onto a clone of the original
+    encrypted cipher, so everything it doesn't individually edit — secondary
+    URIs, custom fields, organization membership — survives verbatim. `--uri`
+    replaces the primary URI and keeps the rest. Folder is resolved by id or
+    case-insensitive name.
+  - New `vault_core::Cipher::from_plain` (the encryption inverse of `decrypt`),
+    `vault_api::BitwardenClient::{create_cipher, update_cipher}` (`POST`/`PUT
+    /api/ciphers`, camelCase request body with a `secureNote` marker on type 2),
+    `Request::Add` / `Request::Edit` and `Response::Saved { id, name }`, and the
+    agent's `add_cipher` / `edit_cipher` (with folder name→id resolution). Tests:
+    3 `from_plain` round-trips (`vault-core`); `resolve_folder` and two
+    `apply_cipher_edits` cases proving a secondary URI survives an edit (agent);
+    and `#[ignore]`d wiremock create/update + secure-note-marker tests (api).
+
+  (`add` + `edit` complete the write verbs; remaining M4: `--json` on
+  `unlock`/`lock`/`sync`/`stop-agent`, and a real re-pull `vault sync`.)
+
 ### Fixed
 
 - **CI is green for the first time (M0–M3 had been red on every push).** Four

crates/vault-agent/src/server.rs

@@ -69,6 +69,7 @@ async fn handle_conn(stream: UnixStream, state: Arc<Mutex<AgentState>>) {
     }
 }
 
+#[allow(clippy::too_many_lines)] // flat one-arm-per-request protocol dispatch reads best in one place
 async fn dispatch(req: Request, state: &Arc<Mutex<AgentState>>) -> Response {
     match req {
         Request::Ping | Request::Status => {
@@ -145,6 +146,62 @@ async fn dispatch(req: Request, state: &Arc<Mutex<AgentState>>) -> Response {
                 Err(e) => Response::Error(e),
             }
         }
+        Request::Add {
+            name,
+            cipher_type,
+            folder,
+            notes,
+            username,
+            password,
+            totp,
+            uri,
+        } => {
+            let w = crate::state::CipherWrite {
+                name: Some(name),
+                folder,
+                notes,
+                username,
+                password,
+                totp,
+                uri,
+            };
+            let mut s = state.lock().await;
+            let res = s.add_cipher(cipher_type, w).await;
+            s.touch();
+            drop(s);
+            match res {
+                Ok(saved) => Response::Saved(saved),
+                Err(e) => Response::Error(e),
+            }
+        }
+        Request::Edit {
+            selector,
+            name,
+            folder,
+            notes,
+            username,
+            password,
+            totp,
+            uri,
+        } => {
+            let w = crate::state::CipherWrite {
+                name,
+                folder,
+                notes,
+                username,
+                password,
+                totp,
+                uri,
+            };
+            let mut s = state.lock().await;
+            let res = s.edit_cipher(&selector, w).await;
+            s.touch();
+            drop(s);
+            match res {
+                Ok(saved) => Response::Saved(saved),
+                Err(e) => Response::Error(e),
+            }
+        }
         Request::Quit => {
             let mut s = state.lock().await;
             s.lock();