@@ -478,6 +478,9 @@ Mutation admission uses a private, version-tagged JSON envelope in the same
 object store. Its identity namespace stays stable across format changes, and an
 unknown format fails closed. It contains explicit typed receipts, not arbitrary
 public response payloads, and is not part of the protobuf storage closure.
+Workspace create/delete admissions include the requested workspace name in the
+key, but omit a workspace UUID guard. Different names have independent request-ID
+namespaces; deletion receipts remain replayable after the target disappears.
 
 Each sandbox policy revision stores the complete provenance annotation map
 supplied with that update. The revision payload is the authoritative immutable
 
@@ -646,17 +646,21 @@ resource_mutation!(
     "CreateWorkspace",
     workspace::handle_create_workspace,
     workspace,
-    async |_req: &CreateWorkspaceRequest, state: &ServerState, principal: &Principal| {
-        global_scope(state, principal)
+    async |req: &CreateWorkspaceRequest, state: &ServerState, principal: &Principal| {
+        let mut scope = global_scope(state, principal)?;
+        scope.name.clone_from(&req.name);
+        Ok(scope)
     }
 );
 deletion_mutation!(
     DeleteWorkspaceRequest,
     DeleteWorkspaceResponse,
     "DeleteWorkspace",
     workspace::handle_delete_workspace,
-    async |_req: &DeleteWorkspaceRequest, state: &ServerState, principal: &Principal| {
-        global_scope(state, principal)
+    async |req: &DeleteWorkspaceRequest, state: &ServerState, principal: &Principal| {
+        let mut scope = global_scope(state, principal)?;
+        scope.name.clone_from(&req.name);
+        Ok(scope)
     }
 );
 resource_mutation!(
 
@@ -183,6 +183,139 @@ async fn sqlite_concurrency_restart_name_reuse_expiry_and_uncertainty() {
     .await;
 }
 
+#[tokio::test]
+async fn workspace_create_request_id_is_scoped_to_each_target() {
+    let state = test_server_state().await;
+    let service = crate::grpc::OpenShellService::new(state.clone());
+    let first = create("scope-a");
+    let second = CreateWorkspaceRequest {
+        name: "scope-b".into(),
+        ..first.clone()
+    };
+    let mut originals = Vec::new();
+    for req in [&first, &second] {
+        let response = service
+            .create_workspace(authed_request(req.clone()))
+            .await
+            .unwrap();
+        assert!(response.metadata().get("openshell-replayed").is_none());
+        let original = response.into_inner();
+        assert_eq!(
+            original
+                .workspace
+                .as_ref()
+                .unwrap()
+                .metadata
+                .as_ref()
+                .unwrap()
+                .name,
+            req.name
+        );
+        assert_eq!(
+            state
+                .store
+                .get_message_by_name::<Workspace>("", &req.name)
+                .await
+                .unwrap(),
+            original.workspace
+        );
+        originals.push(original);
+    }
+    assert_ne!(
+        originals[0].workspace.as_ref().unwrap().object_id(),
+        originals[1].workspace.as_ref().unwrap().object_id()
+    );
+    for (req, original) in [&first, &second].into_iter().zip(originals) {
+        let replay = service
+            .create_workspace(authed_request(req.clone()))
+            .await
+            .unwrap();
+        assert_eq!(replay.metadata().get("openshell-replayed").unwrap(), "true");
+        assert_eq!(replay.into_inner(), original);
+        let mut mismatch = req.clone();
+        mismatch.labels.insert("changed".into(), "payload".into());
+        assert_eq!(
+            reason(
+                &service
+                    .create_workspace(authed_request(mismatch))
+                    .await
+                    .unwrap_err()
+            ),
+            "REQUEST_ID_PAYLOAD_MISMATCH"
+        );
+    }
+    let rows = state
+        .store
+        .list_by_type_after(OBJECT_TYPE, None, 100)
+        .await
+        .unwrap();
+    assert_eq!(rows.len(), 2);
+    for row in rows {
+        let admission: Admission = serde_json::from_slice(&row.payload).unwrap();
+        assert!(admission.workspace_id.is_none());
+    }
+}
+
+#[tokio::test]
+async fn workspace_delete_request_id_is_scoped_to_each_target() {
+    let state = test_server_state().await;
+    let service = crate::grpc::OpenShellService::new(state.clone());
+    let request_id = uuid::Uuid::new_v4().to_string();
+    let mut requests = Vec::new();
+    for name in ["scope-a", "scope-b"] {
+        service
+            .create_workspace(authed_request(CreateWorkspaceRequest {
+                name: name.into(),
+                ..Default::default()
+            }))
+            .await
+            .unwrap();
+        requests.push(DeleteWorkspaceRequest {
+            name: name.into(),
+            request_id: request_id.clone(),
+            ..Default::default()
+        });
+    }
+    for req in &requests {
+        let response = service
+            .delete_workspace(authed_request(req.clone()))
+            .await
+            .unwrap();
+        assert!(response.metadata().get("openshell-replayed").is_none());
+        assert_eq!(
+            response.get_ref().outcome,
+            openshell_core::proto::DeletionOutcome::Completed as i32
+        );
+        assert!(
+            state
+                .store
+                .get_message_by_name::<Workspace>("", &req.name)
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+    for req in requests {
+        // The target no longer exists; deletion replay must not require its UUID.
+        let replay = service.delete_workspace(authed_request(req)).await.unwrap();
+        assert_eq!(replay.metadata().get("openshell-replayed").unwrap(), "true");
+        assert_eq!(
+            replay.get_ref().outcome,
+            openshell_core::proto::DeletionOutcome::Completed as i32
+        );
+    }
+    let rows = state
+        .store
+        .list_by_type_after(OBJECT_TYPE, None, 100)
+        .await
+        .unwrap();
+    assert_eq!(rows.len(), 2);
+    for row in rows {
+        let admission: Admission = serde_json::from_slice(&row.payload).unwrap();
+        assert!(admission.workspace_id.is_none());
+    }
+}
+
 #[tokio::test]
 #[ignore = "requires a disposable PostgreSQL database in OPENSHELL_REPLAY_TEST_DATABASE_URL"]
 async fn postgres_concurrency_restart_name_reuse_expiry_and_uncertainty() {
@@ -463,7 +596,13 @@ impl Mutation for ControlledCreate {
         &self.request_id
     }
     async fn authorize(&self, state: &ServerState, principal: &Principal) -> Result<Scope, Status> {
-        global_scope(state, principal)
+        // Fault-injected execution must use the real adapter's admission key.
+        CreateWorkspaceRequest {
+            name: self.name.clone(),
+            ..Default::default()
+        }
+        .authorize(state, principal)
+        .await
     }
     async fn execute(
         state: &Arc<ServerState>,
 
@@ -111,6 +111,17 @@ subject, RPC method, and requested workspace. Use the same identity, scope, ID,
 and payload when checking an admitted attempt. Map ordering does not affect the
 payload fingerprint; changed values or protobuf message presence do.
 
+For `CreateWorkspace` and `DeleteWorkspace`, the requested workspace is the
+request's `name`. The same caller can reuse an ID for the same method on different
+workspace names. Within one workspace name, a changed payload still returns
+`REQUEST_ID_PAYLOAD_MISMATCH`. Workspace deletion replay does not require the
+deleted workspace to exist and does not delete a same-name replacement.
+
+Pre-release gateways that used unscoped workspace admission require reconciliation
+before upgrading. Their workspace create/delete receipts do not replay under the
+corrected name-scoped namespace. Do not retry those IDs after upgrading without
+reconciling the original operations' effects.
+
 The gateway durably admits one owner before executing the mutation. Concurrent
 duplicates either replay its confirmed success or return
 `REQUEST_OUTCOME_UNCERTAIN`. Disconnecting or cancelling the client does not stop
 
@@ -78,6 +78,61 @@ def test_workspace_get_nonexistent_raises_not_found(
     assert exc_info.value.code() == grpc.StatusCode.NOT_FOUND
 
 
+def test_workspace_request_ids_are_scoped_to_each_target(
+    workspace_client: WorkspaceClient,
+) -> None:
+    names = [f"ws-scope-{uuid.uuid4().hex[:8]}" for _ in range(2)]
+    create_id = str(uuid.uuid4())
+    delete_id = str(uuid.uuid4())
+    stub = workspace_client._stub
+    originals = []
+    try:
+        for name in names:
+            request = openshell_pb2.CreateWorkspaceRequest(
+                name=name, request_id=create_id
+            )
+            response, call = stub.CreateWorkspace.with_call(request, timeout=20)
+            assert "openshell-replayed" not in dict(call.initial_metadata())
+            assert response.workspace.metadata.name == name
+            fetched = stub.GetWorkspace(
+                openshell_pb2.GetWorkspaceRequest(name=name), timeout=20
+            )
+            assert fetched.workspace.metadata.id == response.workspace.metadata.id
+            originals.append(response)
+        assert originals[0].workspace.metadata.id != originals[1].workspace.metadata.id
+
+        for name, original in zip(names, originals, strict=True):
+            replay, call = stub.CreateWorkspace.with_call(
+                openshell_pb2.CreateWorkspaceRequest(name=name, request_id=create_id),
+                timeout=20,
+            )
+            assert replay == original
+            assert dict(call.initial_metadata())["openshell-replayed"] == "true"
+
+        for name in names:
+            request = openshell_pb2.DeleteWorkspaceRequest(
+                name=name, request_id=delete_id
+            )
+            response, call = stub.DeleteWorkspace.with_call(request, timeout=20)
+            assert "openshell-replayed" not in dict(call.initial_metadata())
+            assert response.outcome == openshell_pb2.DELETION_OUTCOME_COMPLETED
+            with pytest.raises(grpc.RpcError) as exc_info:
+                workspace_client.get(name)
+            assert exc_info.value.code() == grpc.StatusCode.NOT_FOUND
+
+        for name in names:
+            replay, call = stub.DeleteWorkspace.with_call(
+                openshell_pb2.DeleteWorkspaceRequest(name=name, request_id=delete_id),
+                timeout=20,
+            )
+            assert replay.outcome == openshell_pb2.DELETION_OUTCOME_COMPLETED
+            assert dict(call.initial_metadata())["openshell-replayed"] == "true"
+    finally:
+        for name in names:
+            with contextlib.suppress(Exception):
+                workspace_client.delete(name, allow_missing=True)
+
+
 def test_workspace_request_id_replays_without_deleting_replacement(
     workspace_client: WorkspaceClient,
 ) -> None:
@@ -109,7 +164,9 @@ def test_workspace_request_id_replays_without_deleting_replacement(
         )
         assert replacement.workspace.metadata.id != original.workspace.metadata.id
         assert stub.DeleteWorkspace(delete, timeout=20) == removed
-        fetched = stub.GetWorkspace(openshell_pb2.GetWorkspaceRequest(name=name), timeout=20)
+        fetched = stub.GetWorkspace(
+            openshell_pb2.GetWorkspaceRequest(name=name), timeout=20
+        )
         assert fetched.workspace.metadata.id == replacement.workspace.metadata.id
     finally:
         with contextlib.suppress(Exception):